home *** CD-ROM | disk | FTP | other *** search
/ Aminet 45 / Aminet 45 (2001)(GTI - Schatztruhe)[!][Oct 2001].iso / Aminet / util / misc / ReportPlus.lha / reportplus / source / f6.c < prev    next >
Encoding:
C/C++ Source or Header  |  2001-08-20  |  83.7 KB  |  2,170 lines

  1. #include <exec/types.h>
  2. #include <exec/memory.h>
  3. #include <intuition/intuition.h>
  4. #include <intuition/gadgetclass.h>
  5. #include <libraries/gadtools.h>
  6. #include <libraries/iffparse.h>
  7. #include <graphics/gfx.h>
  8. #include <dos/dos.h>
  9. #include <dos/datetime.h>
  10.  
  11. #include <clib/alib_protos.h>
  12. #include <clib/exec_protos.h>
  13. #include <clib/intuition_protos.h>
  14. #include <clib/gadtools_protos.h>
  15. #include <clib/iffparse_protos.h>
  16. #include <clib/dos_protos.h>
  17. #include <clib/graphics_protos.h>
  18.  
  19. #include <ctype.h>
  20. #include <stdlib.h>
  21. #include <string.h>
  22. #include "rp.h"
  23.  
  24. #define CHUNKS 35
  25. // Variable-length blocks, and/or blocks that we read entirely, are
  26. // represented as chunksize = 0 and fixed = FALSE.
  27. struct
  28. {   TEXT   formname[5], chunkname[5];
  29.     ULONG  bytes;
  30.     ABOOL  fixed;
  31. } chunks[CHUNKS + 1] =
  32. { {"    ", "(c) ",  0, FALSE}, // "    " means any
  33.   {"    ", "ANNO",  0, FALSE},
  34.   {"    ", "AUTH",  0, FALSE},
  35.   {"    ", "NAME",  0, FALSE},
  36.   {"8SVX", "CHAN",  0, FALSE},
  37.   {"8SVX", "PAN ",  0, FALSE},
  38.   {"8SVX", "FADE",  0, FALSE},
  39.   {"8SVX", "SEQN",  0, FALSE},
  40.   {"8SVX", "VHDR",  0, FALSE},
  41.   {"AIFF", "APPL",  4, TRUE },
  42.   {"AIFF", "COMM",  8, TRUE }, // we currently ignore 'SampleRate' field
  43.   {"AIFF", "COMT",  0, FALSE},
  44.   {"AIFF", "MARK",  0, FALSE},
  45.   {"AIFF", "SSND",  8, TRUE },
  46.   {"AIFF", "INST",  0, FALSE},
  47.   {"FTXT", "FONS",  0, FALSE},
  48.   {"HEAD", "NEST",  0, FALSE},
  49.   {"!!!!", "BMHD",  0, FALSE}, // "!!!!" means "ACBM or ILBM"
  50.   {"!!!!", "CAMG",  0, FALSE},
  51.   {"!!!!", "GRAB",  0, FALSE},
  52.   {"!!!!", "DPI ",  0, FALSE},
  53.   {"!!!!", "DEST",  0, FALSE},
  54.   {"!!!!", "EPSF",  8, TRUE },
  55.   {"!!!!", "SPRT",  0, FALSE},
  56.   {"SMUS", "INS1",  0, FALSE},
  57.   {"SMUS", "SHDR",  0, FALSE},
  58.   {"WORD", "FONT",  0, FALSE},
  59.   {"WORD", "COLR",  0, FALSE},
  60.   {"WORD", "DOC ",  0, FALSE},
  61.   {"WORD", "HEAD",  0, FALSE},
  62.   {"WORD", "FOOT",  0, FALSE},
  63.   {"WORD", "PCTS",  0, FALSE},
  64.   {"WORD", "PARA",  0, FALSE},
  65.   {"WORD", "TABS",  0, FALSE},
  66.   {"WORD", "PINF",  0, FALSE},
  67.   {"####", "FSCC",  0, FALSE}  // "####" means "HEAD or WORD"
  68. };
  69.  
  70. #define ITEMS 255
  71. MODULE struct
  72. {   TEXT   name[5];
  73.     ULONG  bytes;
  74.     UBYTE* DataPtr;
  75. } contents[ITEMS + 1];
  76.  
  77. #define FORMS         89
  78.  
  79. #define CD             1
  80. #define OBSOLETE       2
  81. #define PRIVATE        4
  82. #define PROPOSAL       8
  83. #define RESERVED      16
  84. #define RKM           32
  85. #define STANDARD      64
  86. #define UNREGISTERED 128
  87.  
  88. #define IFFXCHARS     17
  89.  
  90. MODULE void iffquery(void);
  91. MODULE void PrintTopChunk(void);
  92. MODULE void readiff(void);
  93. MODULE void tellchunk(UWORD which);
  94. MODULE void chunkdesc(STRPTR desc);
  95. MODULE void binarize(UBYTE data);
  96. MODULE ULONG getulong(UBYTE* start);
  97. MODULE SLONG getslong(UBYTE* start);
  98. MODULE ULONG getuword(UBYTE* start);
  99. MODULE SLONG getsword(UBYTE* start);
  100. MODULE SLONG getsbyte(UBYTE* start);
  101. MODULE void writeiffgadgets(void);
  102.  
  103. /* Text error messages for possible IFFERR_#? returns from various IFF
  104.  * routines. To get the index into this array, take your IFFERR code,
  105.  * negate it, and subtract one.
  106.  * idx = -error - 1;
  107.  */
  108. STRPTR errormsgs[] =
  109. {   "End of file (not an error).",
  110.     "End of context (not an error).",
  111.     "No lexical scope.",
  112.     "Insufficient memory.",
  113.     "Stream read error.",
  114.     "Stream write error.",
  115.     "Stream seek error.",
  116.     "File is corrupt.",
  117.     "IFF syntax error.",
  118.     "Not an IFF file.",
  119.     "Required call-back hook missing.",
  120.     "Return to client. You should never see this."
  121. };
  122.  
  123. // from rp.c
  124. IMPORT ABOOL             fillwindows;
  125. IMPORT SBYTE             page;
  126. IMPORT struct NewGadget  Gadget;
  127. IMPORT struct Gadget    *BU99_Right,
  128.                         *PrevGadPtr;
  129. IMPORT struct Window*    MainWindowPtr;
  130. IMPORT TEXT              aslresult[VLONGFIELD + 1],
  131.                          weekdaystring[LEN_DATSTRING],
  132.                          datestring[LEN_DATSTRING],
  133.                          timestring[LEN_DATSTRING];
  134.  
  135. MODULE ABOOL             known;
  136. MODULE struct IFFHandle* IFFHandle             = NULL;
  137. MODULE struct List       List1,
  138.                          List2;
  139. MODULE ABOOL             List1Nodes            = FALSE,
  140.                          List2Nodes            = FALSE;
  141. MODULE struct Gadget  *TE61_Contributor        = NULL,
  142.                       *CB61_CD                 = NULL,
  143.                       *CB61_Obsolete           = NULL,
  144.                       *TE61_FORMDesc           = NULL,
  145.                       *ST61_FORMID             = NULL,
  146.                       *CB61_Private            = NULL,
  147.                       *CB61_Proposal           = NULL,
  148.                       *CB61_Reserved           = NULL,
  149.                       *CB61_RKM                = NULL,
  150.                       *CB61_Standard           = NULL,
  151.                       *CB61_Unregistered       = NULL,
  152.                       *TE61_Status             = NULL,
  153.                       *ST61_Pathname           = NULL,
  154.                       *BU61_PathnameASL        = NULL,
  155.                       *LV61_List1              = NULL,
  156.                       *LV61_List2              = NULL,
  157.                       *TE61_ChunkDesc          = NULL;
  158. MODULE TEXT  queryform[5] = "",
  159.              tempstring1[VLONGFIELD + 1],
  160.              tempstring2[13];
  161. MODULE ULONG items = 0; // value of this is actual number of items allocated
  162. MODULE UWORD selectedform = 0;
  163. AGLOBAL struct IFFStruct iff;
  164. MODULE struct
  165. {   UBYTE  flags;
  166.     TEXT   name[5];
  167.     STRPTR desc;
  168.     STRPTR contributor;
  169. } form[FORMS + 1] =
  170. {   STANDARD | RKM | CD,      "8SVX", "EA IFF 85 8-bit sound sample form",                    "EA/CBM",
  171.     RKM | CD,                 "AIFF", "Audio 1-32 bit samples",                               "Apple",
  172.     RKM | CD,                 "ACBM", "Amiga Contiguous Bitmap",                              "CBM",
  173.     UNREGISTERED,             "AHAM", "?",                                                    "?",
  174.     RKM | CD,                 "ANBM", "Animated BitMap form",                                 "EA",
  175.     RKM | CD,                 "ANIM", "CEL ANIMation form",                                   "Sparta/Aegis",
  176.     PROPOSAL,                 "ARC ", "ARChive format",                                       "?",
  177.     UNREGISTERED,             "ARES", "?",                                                    "?",
  178.     RESERVED,                 "ATXT", "Temporarily reserved",                                 "?",
  179.     PRIVATE,                  "AVCF", "AmigaVision Flow",                                     "CBM",
  180.     NULL,                     "BANK", "Soundquest Editor/Librarian MIDI Sysex dump",          "?",
  181.     NULL,                     "BBSD", "BBS Database",                                         "Phalanx Software",
  182.     PRIVATE,                  "C100", "?",                                                    "Cloanto",
  183.     STANDARD,                 "CAT ", "EA IFF 85 group identifier",                           "EA/CBM",
  184.     PROPOSAL,                 "CELP", "Compressed ZyXEL voice data",                          "?",
  185.     RESERVED,                 "CHBM", "Chunky bitmap",                                        "Eric Lavitsky",
  186.     NULL,                     "CLIP", "CAT CLIP to hold various formats in clipboard",        "CBM",
  187.     PROPOSAL | CD,            "CMUS", "Common MUsical Score",                                 "Talin (David Joiner)",
  188.     NULL,                     "CPFM", "Cloanto Personal FontMaker",                           "Cloanto",
  189.     NULL,                     "DCCL", "DCTV paint clip",                                      "?",
  190.     NULL,                     "DCPA", "DCTV paint palette",                                   "?",
  191.     NULL,                     "DCTV", "DCTV raw picture file",                                "?",
  192.     PRIVATE,                  "DECK", "Inovatronics CanDo",                                   "Innovatronics",
  193.     CD,                       "DEEP", "Chunky pixel image files (used in TV Paint)",          "Amiga Centre Scotland",
  194.     RKM | CD,                 "DR2D", "2D object standard format",                            "Ross Cunniff & John Orr",
  195.     RESERVED,                 "DRAW", "?",                                                    "Jim Bayless",
  196.     CD,                       "DTYP", "DataTYPes identification",                             "Amiga, Inc.",
  197.     PROPOSAL | CD,            "EXEC", "Executable (loadseg-able) code",                       "Chris Ludwig",
  198.     RKM | CD,                 "FANT", "Fantavision movie format",                             "Broderbund",
  199.     OBSOLETE | PRIVATE,       "FAX3", "Facsimile image",                                      "GPSoftware",
  200.     CD,                       "FAXX", "Facsimile image",                                      "Atlantis Design Group",
  201.     RESERVED,                 "FIGR", "Deluxe Video",                                         "EA",
  202.     NULL,                     "FILM", "LIST FILM - stores ILBMs with interleaved 8SVX audio", "?",
  203.     RESERVED,                 "FNTR", "Raster font",                                          "EA",
  204.     RESERVED,                 "FNTV", "Vector font",                                          "EA",
  205.     STANDARD,                 "FORM", "Group identifier",                                     "EA/CBM",
  206.     STANDARD | RKM,           "FTXT", "Formatted TeXT",                                       "EA/CBM",
  207.     PROPOSAL | PRIVATE,       "GRYP", "Byteplane storage",                                    "?",
  208.     RESERVED,                 "GSCR", "General music SCoRe",                                  "EA",
  209.     PROPOSAL | PRIVATE,       "GUI ", "User interface storage",                               "?",
  210.     RKM | CD,                 "HEAD", "Flow idea processor",                                  "New Horizons Software",
  211.     STANDARD | RKM | CD,      "ILBM", "EA IFF 85 raster bitmap form",                         "EA/CBM",
  212.     RESERVED,                 "IOBJ", "?",                                                    "Seven Seas Software",
  213.     RESERVED,                 "IODK", "?",                                                    "Merging Technologies",
  214.     RESERVED,                 "ITRF", "?",                                                    "?",
  215.     RESERVED,                 "JMOV", "?",                                                    "Merging Technologies",
  216.     STANDARD,                 "LIST", "EA IFF 85 group identifier",                           "EA/CBM",
  217.     RESERVED,                 "MFAX", "Facsimile?",                                           "TKR GmbH & Co.",
  218.     NULL,                     "MIDI", "MIDI?",                                                "Circum Design",
  219.     PRIVATE,                  "MOVI", "LIST MOVIe?",                                          "?",
  220.     PRIVATE,                  "MSCX", "Music-X format",                                       "?",
  221.     RESERVED,                 "MSMP", "Temporarily reserved",                                 "?",
  222.     RKM | CD,                 "MTRX", "Numerical data storage (MathVision)",                  "Seven Seas Software",
  223.     NULL,                     "NSEQ", "Numerical sequence",                                   "Stockhausen GmbH",
  224.     PROPOSAL | CD,            "OB3D", "Standard 3D object",                                   "?",
  225.     RKM | CD,                 "PGTB", "ProGram TraceBack",                                    "SAS Institute",
  226.     RESERVED,                 "PICS", "Macintosh picture",                                    "EA",
  227.     RESERVED | OBSOLETE,      "PLBM", "?",                                                    "EA",
  228.     RESERVED | PROPOSAL | CD, "PMBC", "24-bit accurate images",                               "Black Belt Systems",
  229.     RESERVED | PRIVATE,       "PREF", "User preferences data",                                "CBM",
  230.     STANDARD,                 "PROP", "Group identifier",                                     "EA/CBM",
  231.     RKM | CD,                 "PRSP", "DPaint IV perspective move form",                      "EA",
  232.     NULL,                     "PTCH", "Patch file",                                           "SAS Institute",
  233.     RESERVED,                 "PTXT", "Temporarily reserved",                                 "?",
  234.     NULL,                     "RGB4", "4-bit RGB",                                            "?",
  235.     RKM | CD,                 "RGB8", "RGB image (Turbo Silver)",                             "Impulse",
  236.     RKM | CD,                 "RGBN", "RGB image (Turbo Silver)",                             "Impulse",
  237.     RESERVED,                 "RGBX", "Temporarily reserved",                                 "?",
  238.     PRIVATE,                  "ROXN", "Animation",                                            "?",
  239.     RKM | CD,                 "SAMP", "Sampled sound",                                        "Jim Fiore & Jeff Glatt",
  240.     PRIVATE,                  "SC3D", "SCene format (Sculpt-3D)",                             "?",
  241.     PRIVATE,                  "SHAK", "SHAKespeare format",                                   "?",
  242.     RESERVED | PRIVATE,       "SHO1", "?",                                                    "Gary Bonham",
  243.     RESERVED | PRIVATE,       "SHOW", "?",                                                    "Gary Bonham",
  244.     STANDARD | RKM,           "SMUS", "Simple MUsic Score",                                   "EA/CBM",
  245.     CD,                       "SPLT", "File SPLiTting system",                                "ASDG",
  246.     RESERVED,                 "SSRE", "?",                                                    "Merging Technologies",
  247.     UNREGISTERED,             "SWRT", "?",                                                    "?",
  248.     NULL,                     "SYTH", "SoundQuest Master Librarian MIDI System driver",       "?",
  249.     RESERVED,                 "TCDE", "?",                                                    "Merging Technologies",
  250.     RKM | CD,                 "TDDD", "3D rendering data (Turbo Silver)",                     "Impulse",
  251.     UNREGISTERED,             "TERM", "?",                                                    "?",
  252.     CD,                       "TMUI", "ToolMaker User Interface",                             "Michael Erwin",
  253.     CD,                       "TREE", "Arbitrary data structures as trees (or nested lists)", "Stefan Reisner",
  254.     CD | PROPOSAL,            "TRKR", "TRacKeR style music module",                           "Full Tilt Entertainment",
  255.     RESERVED,                 "USCR", "Uhuru SCoRe",                                          "EA",
  256.     RESERVED,                 "UVOX", "Uhuru Macintosh VOiXe",                                "EA",
  257.     PRIVATE,                  "VDEO", "Deluxe ViDEO",                                         "EA",
  258.     RKM | CD,                 "WORD", "ProWrite document",                                    "New Horizons Software",
  259.     CD,                       "YUVN", "For storage of Y:U:V image data",                      "MacroSystem"
  260. };
  261.  
  262. AGLOBAL void iff1(void)
  263. {   verynewwindow
  264.     (   IFF1WIDTH, IFF1HEIGHT,
  265.         "Report+: IFF Registry",
  266.         BUTTONIDCMP | STRINGIDCMP | LISTVIEWIDCMP
  267.     );
  268.     if (fillwindows)
  269.     {   SetAPen(MainWindowPtr->RPort, 0);
  270.         RectFill(MainWindowPtr->RPort,  10, 120,  10 + 160, 120 +  68 - 1); // LV61_List1
  271.         RectFill(MainWindowPtr->RPort, 180, 120, 180 + 450, 120 +  68 - 1); // LV61_List2
  272.         RectFill(MainWindowPtr->RPort, 130,  34, 130 + 440,  34 +  12); // TE61_FORMDesc
  273.         RectFill(MainWindowPtr->RPort, 130,  46, 130 + 440,  46 +  12); // TE61_Contributor
  274.         RectFill(MainWindowPtr->RPort, 130,  58, 130 + 440,  58 +  12); // TE61_ChunkDesc
  275.         RectFill(MainWindowPtr->RPort, 130, 200, 130 + 350, 200 +  12); // TE61_Status
  276.     }
  277.  
  278.     /* FORM ID */
  279.     setgadget(130, 22, 56, 12, "_FORM ID:", NULL);
  280.     ST61_FORMID = PrevGadPtr = (struct Gadget *) CreateGadget
  281.     (   STRING_KIND,
  282.         PrevGadPtr,
  283.         &Gadget,
  284.         GTST_String, queryform,
  285.         GTST_MaxChars, 4,
  286.         GA_TabCycle, TRUE,
  287.         GA_Immediate, TRUE,
  288.         GT_Underscore, '_',
  289.         STRINGA_ReplaceMode, TRUE,
  290.         TAG_DONE
  291.     );
  292.     /* FORM description */
  293.     setgadget(130, 34, 440, 12, "Description:", NULL);
  294.     TE61_FORMDesc = PrevGadPtr = (struct Gadget *) CreateGadget
  295.     (   TEXT_KIND,
  296.         PrevGadPtr,
  297.         &Gadget,
  298.         GTTX_Text, "-",
  299.         GTTX_Border, TRUE,
  300.         TAG_DONE
  301.     );
  302.     /* contributor name */
  303.     setgadget(130, 46, 440, 12, "Contributor:", NULL);
  304.     TE61_Contributor = PrevGadPtr = (struct Gadget *) CreateGadget
  305.     (   TEXT_KIND,
  306.         PrevGadPtr,
  307.         &Gadget,
  308.         GTTX_Text, "-",
  309.         GTTX_Border, TRUE,
  310.         TAG_DONE
  311.     );
  312.     /* chunk description */
  313.     setgadget(130, 58, 440, 12, "Chunk info:", NULL);
  314.     TE61_ChunkDesc = PrevGadPtr = (struct Gadget *) CreateGadget
  315.     (   TEXT_KIND,
  316.         PrevGadPtr,
  317.         &Gadget,
  318.         GTTX_Text, "-",
  319.         GTTX_Border, TRUE,
  320.         TAG_DONE
  321.     );
  322.  
  323.     /* flags */
  324.     setgadget(130, 76, 0, 0, "Obsolete:", NULL);
  325.     CB61_Obsolete = PrevGadPtr = (struct Gadget *) CreateGadget
  326.     (   CHECKBOX_KIND,
  327.         PrevGadPtr,
  328.         &Gadget,
  329.         GA_Disabled, TRUE,
  330.         GTCB_Checked, iff.obsolete,
  331.         TAG_DONE
  332.     );
  333.     setgadget(130, 90, 0, 0, "Private:", NULL);
  334.     CB61_Private = PrevGadPtr = (struct Gadget *) CreateGadget
  335.     (   CHECKBOX_KIND,
  336.         PrevGadPtr,
  337.         &Gadget,
  338.         GA_Disabled, TRUE,
  339.         GTCB_Checked, iff.private,
  340.         TAG_DONE
  341.     );
  342.     setgadget(282, 76, 0, 0, "Proposal:", NULL);
  343.     CB61_Proposal = PrevGadPtr = (struct Gadget *) CreateGadget
  344.     (   CHECKBOX_KIND,
  345.         PrevGadPtr,
  346.         &Gadget,
  347.         GA_Disabled, TRUE,
  348.         GTCB_Checked, iff.proposal,
  349.         TAG_DONE
  350.     );
  351.     setgadget(282, 90, 0, 0, "Reserved:", NULL);
  352.     CB61_Reserved = PrevGadPtr = (struct Gadget *) CreateGadget
  353.     (   CHECKBOX_KIND,
  354.         PrevGadPtr,
  355.         &Gadget,
  356.         GA_Disabled, TRUE,
  357.         GTCB_Checked, iff.reserved,
  358.         TAG_DONE
  359.     );
  360.     setgadget(434, 76, 0, 0, "Standard:", NULL);
  361.     CB61_Standard = PrevGadPtr = (struct Gadget *) CreateGadget
  362.     (   CHECKBOX_KIND,
  363.         PrevGadPtr,
  364.         &Gadget,
  365.         GA_Disabled, TRUE,
  366.         GTCB_Checked, iff.standard,
  367.         TAG_DONE
  368.     );
  369.     setgadget(434, 90, 0, 0, "Unregistered:", NULL);
  370.     CB61_Unregistered = PrevGadPtr = (struct Gadget *) CreateGadget
  371.     (   CHECKBOX_KIND,
  372.         PrevGadPtr,
  373.         &Gadget,
  374.         GA_Disabled, TRUE,
  375.         GTCB_Checked, iff.unregistered,
  376.         TAG_DONE
  377.     );
  378.     setgadget(588, 76, 0, 0, "RKM:", NULL);
  379.     CB61_RKM = PrevGadPtr = (struct Gadget *) CreateGadget
  380.     (   CHECKBOX_KIND,
  381.         PrevGadPtr,
  382.         &Gadget,
  383.         GA_Disabled, TRUE,
  384.         GTCB_Checked, iff.rkm,
  385.         TAG_DONE
  386.     );
  387.     setgadget(588, 90, 0, 0, "CD-ROM:", NULL);
  388.     CB61_CD = PrevGadPtr = (struct Gadget *) CreateGadget
  389.     (   CHECKBOX_KIND,
  390.         PrevGadPtr,
  391.         &Gadget,
  392.         GA_Disabled, TRUE,
  393.         GTCB_Checked, iff.cd,
  394.         TAG_DONE
  395.     );
  396.  
  397.     setgadget( 10, 120, 160, 68, "Chunks:", NULL);
  398.     LV61_List1 = PrevGadPtr = (struct Gadget *) CreateGadget
  399.     (   LISTVIEW_KIND,
  400.         PrevGadPtr,
  401.         &Gadget,
  402.         GTLV_Labels, NULL,
  403.         GTLV_ShowSelected, NULL,
  404.         TAG_DONE
  405.     );
  406.     setgadget(180, 120, 450, 68, "Chunk contents:", NULL);
  407.     LV61_List2 = PrevGadPtr = (struct Gadget *) CreateGadget
  408.     (   LISTVIEW_KIND,
  409.         PrevGadPtr,
  410.         &Gadget,
  411.         GTLV_Labels, NULL,
  412.         TAG_DONE
  413.     );
  414.  
  415.     /* status */
  416.     setgadget(130, 200, 350, 12, "Status:", NULL);
  417.     TE61_Status = PrevGadPtr = (struct Gadget *) CreateGadget
  418.     (   TEXT_KIND,
  419.         PrevGadPtr,
  420.         &Gadget,
  421.         GTTX_Text, "Ready.",
  422.         GTTX_Border, TRUE,
  423.         TAG_DONE
  424.     );
  425.  
  426.     /* pathname */
  427.     setgadget(130, 214, 320, 12, "_Pathname:", NULL);
  428.     ST61_Pathname = PrevGadPtr = (struct Gadget *) CreateGadget
  429.     (   STRING_KIND,
  430.         PrevGadPtr,
  431.         &Gadget,
  432.         GTST_String, iff.pathname,
  433.         GTST_MaxChars, VLONGFIELD,
  434.         GA_TabCycle, TRUE,
  435.         GA_Immediate, TRUE,
  436.         GT_Underscore, '_',
  437.         TAG_DONE
  438.     );
  439.     /* pathname... */
  440.     setgadget(452, 214, 28, 12, "_...", NULL);
  441.     BU61_PathnameASL = PrevGadPtr = (struct Gadget *) CreateGadget
  442.     (   BUTTON_KIND,
  443.         PrevGadPtr,
  444.         &Gadget,
  445.         GT_Underscore, '_',
  446.         TAG_DONE
  447.     );
  448.  
  449.     drawgadgets((UWORD) ~0);
  450.     if (iff.pathname[0])
  451.     {   readiff();
  452.     } elif (queryform[0])
  453.     {   iffquery();
  454.     }
  455.     ActivateGadget(ST61_Pathname, MainWindowPtr, NULL);
  456.     loop();
  457.     strcpy
  458.     (   queryform,
  459.         ((struct StringInfo *) ST61_FORMID->SpecialInfo)->Buffer
  460.     );
  461.     strcpy
  462.     (   iff.pathname,
  463.         ((struct StringInfo *) ST61_Pathname->SpecialInfo)->Buffer
  464.     );
  465.     closewindow();
  466. }
  467.  
  468. AGLOBAL void iff_loop(ULONG class, struct Gadget* addr, UWORD code, UWORD qual)
  469. {   if (class == IDCMP_VANILLAKEY)
  470.     {   code = toupper(code);
  471.         if (code == ESCAPE)
  472.             page = 0;
  473.         elif (code == 'F')
  474.             ActivateGadget(ST61_FORMID, MainWindowPtr, NULL);
  475.         elif (code == 'P')
  476.             ActivateGadget(ST61_Pathname, MainWindowPtr, NULL);
  477.         elif (code == '.')
  478.         {   if (asl())
  479.             {   strcpy(iff.pathname, aslresult);
  480.                 GT_SetGadgetAttrs
  481.                 (   ST61_Pathname,
  482.                     MainWindowPtr,
  483.                     NULL,
  484.                     GTST_String, iff.pathname,
  485.                     TAG_DONE
  486.                 );
  487.                 readiff();
  488.     }   }   }
  489.     elif (class == IDCMP_GADGETUP)
  490.     {   /* IDCMP_GADGETUP is sent by the string gadget
  491.         when the user presses RETURN, ENTER, Help, Tab
  492.         or Shift-Tab inside the string gadget. */
  493.         
  494.         if (addr == BU99_Right)
  495.             page = 0;
  496.         elif (addr == ST61_Pathname)
  497.     {   strcpy
  498.             (   iff.pathname,
  499.                 ((struct StringInfo *) ST61_Pathname->SpecialInfo)->Buffer
  500.         );
  501.             readiff();
  502.         } elif (addr == ST61_FORMID)
  503.         {   strcpy
  504.             (   queryform,
  505.                 ((struct StringInfo *) ST61_FORMID->SpecialInfo)->Buffer
  506.         );
  507.             iff.pathname[0] = 0;
  508.             GT_SetGadgetAttrs
  509.             (   ST61_Pathname,
  510.                 MainWindowPtr,
  511.                 NULL,
  512.                 GTST_String, iff.pathname,
  513.                 TAG_DONE
  514.             );
  515.             GT_SetGadgetAttrs
  516.             (   TE61_Status,
  517.                 MainWindowPtr,
  518.                 NULL,
  519.                 GTTX_Text, "Ready.",
  520.                 TAG_DONE
  521.             );
  522.             iffquery();
  523.         } elif (addr == BU61_PathnameASL)
  524.         {   if (asl())
  525.             {   strcpy(iff.pathname, aslresult);
  526.                 GT_SetGadgetAttrs
  527.                 (   ST61_Pathname,
  528.                     MainWindowPtr,
  529.                     NULL,
  530.                     GTST_String, iff.pathname,
  531.                     TAG_DONE
  532.                 );
  533.                 readiff();
  534.         }   }
  535.         elif (addr == LV61_List1)
  536.         {   tellchunk(code + 1);
  537. }   }   }
  538.  
  539. MODULE void iffquery(void)
  540. {   ULONG i;
  541.  
  542.     /* Make any corrections to input now, to make it
  543.     easier to search the database. */
  544.     for (i = 0; i <= 3; i++)
  545.         if (queryform[i] >= 97 && queryform[i] <= 122)
  546.             queryform[i] -= 32;
  547.         elif (queryform[i] == 0)
  548.             queryform[i] = ' ';
  549.     queryform[4] = 0;
  550.     GT_SetGadgetAttrs
  551.     (   ST61_FORMID,
  552.         MainWindowPtr,
  553.         NULL,
  554.         GTTX_Text, queryform,
  555.         TAG_DONE
  556.     );
  557.     selectedform = (UWORD) -1;
  558.     for (i = 0; i <= FORMS; i++)
  559.     if
  560.     (   queryform[0] == form[i].name[0]
  561.      && queryform[1] == form[i].name[1]
  562.      && queryform[2] == form[i].name[2]
  563.      && queryform[3] == form[i].name[3]
  564.     )
  565.     {   selectedform = i;
  566.         break;
  567.     }
  568.     if (selectedform == (UWORD) -1)
  569.     {   iff.cd           =
  570.         iff.rkm          =
  571.         iff.private      =
  572.         iff.proposal     =
  573.         iff.obsolete     =
  574.         iff.reserved     =
  575.         iff.standard     =
  576.         iff.unregistered = FALSE;
  577.         GT_SetGadgetAttrs
  578.         (   TE61_FORMDesc,
  579.             MainWindowPtr,
  580.             NULL,
  581.             GTTX_Text, "-",
  582.             TAG_DONE
  583.         );
  584.         GT_SetGadgetAttrs
  585.         (   TE61_Contributor,
  586.             MainWindowPtr,
  587.             NULL,
  588.             GTTX_Text, "-",
  589.             TAG_DONE
  590.         );
  591.     } else
  592.     {   iff.cd           = form[selectedform].flags & CD;
  593.         iff.rkm          = form[selectedform].flags & RKM;
  594.         iff.private      = form[selectedform].flags & PRIVATE;
  595.         iff.proposal     = form[selectedform].flags & PROPOSAL;
  596.         iff.obsolete     = form[selectedform].flags & OBSOLETE;
  597.         iff.reserved     = form[selectedform].flags & RESERVED;
  598.         iff.standard     = form[selectedform].flags & STANDARD;
  599.         iff.unregistered = form[selectedform].flags & UNREGISTERED;
  600.         GT_SetGadgetAttrs
  601.         (   TE61_FORMDesc,
  602.             MainWindowPtr,
  603.             NULL,
  604.             GTTX_Text, form[selectedform].desc,
  605.             TAG_DONE
  606.         );
  607.         GT_SetGadgetAttrs
  608.         (   TE61_Contributor,
  609.             MainWindowPtr,
  610.             NULL,
  611.             GTTX_Text, form[selectedform].contributor,
  612.             TAG_DONE
  613.         );
  614.     }
  615.  
  616.     writeiffgadgets();
  617.  
  618.     GT_SetGadgetAttrs
  619.     (   LV61_List1,
  620.         MainWindowPtr,
  621.         NULL,
  622.         GTLV_Labels, (UWORD) ~0,
  623.         TAG_DONE
  624.     );
  625.     if (List1Nodes)
  626.     {   FreeNameNodes(&List1);
  627.         List1Nodes = FALSE;
  628.     }
  629.     NewList(&List1);
  630.     GT_SetGadgetAttrs
  631.     (   LV61_List1,
  632.         MainWindowPtr,
  633.         NULL,
  634.         GTLV_Labels, &List1,
  635.         GTLV_Selected, (UWORD) ~0,
  636.         TAG_DONE
  637.     );
  638.  
  639.     GT_SetGadgetAttrs
  640.     (   LV61_List2,
  641.         MainWindowPtr,
  642.         NULL,
  643.         GTLV_Labels, (UWORD) ~0,
  644.         TAG_DONE
  645.     );
  646.     if (List2Nodes)
  647.     {   FreeNameNodes(&List2);
  648.         List2Nodes = FALSE;
  649.     }
  650.     NewList(&List2);
  651.     GT_SetGadgetAttrs
  652.     (   LV61_List2,
  653.         MainWindowPtr,
  654.         NULL,
  655.         GTLV_Labels, &List2,
  656.         GTLV_Selected, (UWORD) ~0,
  657.         TAG_DONE
  658.     );
  659.  
  660.     for (i = 0; i < items; i++)
  661.     {   if (contents[i].DataPtr)
  662.         {   FreeMem(contents[i].DataPtr, contents[i].bytes);
  663.             contents[i].DataPtr = NULL;
  664.     }   }
  665.     items = 0;
  666. }
  667.  
  668. MODULE void readiff(void)
  669. {   LONG error;
  670.  
  671.     iffquery();
  672.  
  673.     /* Allocate IFF_File structure. */
  674.     if (!(IFFHandle = AllocIFF()))
  675.     {   DisplayBeep(NULL);
  676.         GT_SetGadgetAttrs
  677.         (   TE61_Status,
  678.             MainWindowPtr,
  679.             NULL,
  680.             GTTX_Text, "AllocIFF() failed!",
  681.             TAG_DONE
  682.         );
  683.         goto bye;
  684.     }
  685.  
  686.     /* Set up IFF_File for AmigaDOS I/O.  */
  687.     if (!(IFFHandle->iff_Stream = Open(iff.pathname, MODE_OLDFILE)))
  688.     {   DisplayBeep(NULL);
  689.         GT_SetGadgetAttrs
  690.         (   TE61_Status,
  691.             MainWindowPtr,
  692.             NULL,
  693.             GTTX_Text, "Can't open file!",
  694.             TAG_DONE
  695.         );
  696.         GT_SetGadgetAttrs
  697.         (   TE61_FORMDesc,
  698.             MainWindowPtr,
  699.             NULL,
  700.             GTTX_Text, "-",
  701.             TAG_DONE
  702.         );
  703.         GT_SetGadgetAttrs
  704.         (   TE61_Contributor,
  705.             MainWindowPtr,
  706.             NULL,
  707.             GTTX_Text, "-",
  708.             TAG_DONE
  709.         );
  710.         queryform[0]     = 0;
  711.         iff.obsolete     =
  712.         iff.private      =
  713.         iff.proposal     =
  714.         iff.reserved     =
  715.         iff.standard     =
  716.         iff.unregistered =
  717.         iff.rkm          =
  718.         iff.cd           = FALSE;
  719.         writeiffgadgets();
  720.         goto bye;
  721.     }
  722.     InitIFFasDOS(IFFHandle);
  723.  
  724.     /* Start the IFF transaction. */
  725.     if (error = OpenIFF(IFFHandle, IFFF_READ))
  726.     {   DisplayBeep(NULL);
  727.         GT_SetGadgetAttrs
  728.         (   TE61_Status,
  729.             MainWindowPtr,
  730.             NULL,
  731.             GTTX_Text, "OpenIFF() failed!",
  732.             TAG_DONE
  733.         );
  734.         goto bye;
  735.     }
  736.  
  737.     while (1)
  738.     {   /* IFFPARSE_RAWSTEP permits us to have precision monitoring of the
  739.          * parsing process, which is necessary if we wish to print the
  740.          * structure of an IFF file.
  741.          *   ParseIFF() with _RAWSTEP will return the following things for
  742.          * the following reasons:
  743.          *
  744.          * Return code:                 Reason:
  745.          * 0                            Entered new context.
  746.          * IFFERR_EOC                   About to leave a context.
  747.          * IFFERR_EOF                   Encountered end-of-file.
  748.          * <anything else>              A parsing error.
  749.          */
  750.         error = ParseIFF(IFFHandle, IFFPARSE_RAWSTEP);
  751.  
  752.         /*
  753.          * Since we're only interested in when we enter a context, we
  754.          * "discard" end-of-context (_EOC) events.
  755.          */
  756.         if (error == IFFERR_EOC)
  757.             continue;
  758.         elif (error)
  759.         {   // Leave the loop if there is any other error.
  760.             break;
  761.         }
  762.  
  763.         /* If we get here, error was zero. Print out the current state of
  764.          * affairs. */
  765.         PrintTopChunk();
  766.     }
  767.  
  768.     /* If error was IFFERR_EOF, then the parser encountered the end of
  769.      * the file without problems. Otherwise, we print a diagnostic.
  770.      */
  771.     if (error == IFFERR_EOF)
  772.     {   GT_SetGadgetAttrs
  773.         (   TE61_Status,
  774.             MainWindowPtr,
  775.             NULL,
  776.             GTTX_Text, "Done.",
  777.             TAG_DONE
  778.         );
  779.         GT_SetGadgetAttrs
  780.         (   LV61_List1,
  781.             MainWindowPtr,
  782.             NULL,
  783.             GTLV_Labels, &List1,
  784.             GTLV_Selected, (UWORD) ~0,
  785.             TAG_DONE
  786.         );
  787.     } else
  788.     {   GT_SetGadgetAttrs
  789.         (   TE61_Status,
  790.             MainWindowPtr,
  791.             NULL,
  792.             GTTX_Text, errormsgs[-error - 1],
  793.             TAG_DONE
  794.         );
  795.         GT_SetGadgetAttrs
  796.         (   LV61_List1,
  797.             MainWindowPtr,
  798.             NULL,
  799.             GTLV_Labels, NULL,
  800.             TAG_DONE
  801.         );
  802.     }
  803.  
  804. bye:
  805.     if (IFFHandle)
  806.     {   /* Terminate the IFF transaction with the stream. Free all
  807.          * associated structures. */
  808.         CloseIFF(IFFHandle);
  809.         // Close the stream itself.
  810.         if (IFFHandle->iff_Stream)
  811.         {   Close(IFFHandle->iff_Stream);
  812.         }
  813.         // Free the IFF_File structure itself.
  814.         FreeIFF(IFFHandle);
  815.         IFFHandle = NULL;
  816. }   }
  817.  
  818. AGLOBAL void iff_exit(void)
  819. {   ULONG i;
  820.  
  821.     if (IFFHandle)
  822.     {   /* Terminate the IFF transaction with the stream. Free all
  823.          * associated structures. */
  824.         CloseIFF(IFFHandle);
  825.         // Close the stream itself.
  826.         if (IFFHandle->iff_Stream)
  827.         {   Close(IFFHandle->iff_Stream);
  828.         }
  829.         // Free the IFF_File structure itself.
  830.         FreeIFF(IFFHandle);
  831.         IFFHandle = NULL;
  832.     }
  833.  
  834.     if (List2Nodes)
  835.     {   FreeNameNodes(&List2);
  836.         List2Nodes = FALSE;
  837.     }
  838.     if (List1Nodes)
  839.     {   FreeNameNodes(&List1);
  840.         List1Nodes = NULL;
  841.     }
  842.     for (i = 0; i < items; i++)
  843.     {   if (contents[i].DataPtr)
  844.         {   FreeMem(contents[i].DataPtr, contents[i].bytes);
  845.             contents[i].DataPtr = NULL;
  846.     }   }
  847.     items = 0;
  848. }
  849.  
  850. MODULE void PrintTopChunk(void)
  851. {   struct ContextNode* top;
  852.     short               i;
  853.     char                idbuf[5];
  854.     ULONG               length;
  855.  
  856.     /* Get a pointer to the context node describing the current context. */
  857.     if (!(top = CurrentChunk(IFFHandle)))
  858.         return;
  859.  
  860.     /* Print spaces equivalent to the current nesting depth of chunks
  861.      * processed so far.
  862.      *   This will cause nested chunks to be printed out indented. */
  863.  
  864.     strcpy(tempstring1, "");
  865.     for (i = IFFHandle->iff_Depth - 1; i--; )
  866.         strcat(tempstring1, " ");
  867.  
  868.     strcpy(contents[items].name, IDtoStr(top->cn_ID, idbuf));
  869.     contents[items].DataPtr = NULL;
  870.  
  871.     /* Print out the current chunk's ID and size. */
  872.     strcat(tempstring1, IDtoStr(top->cn_ID, idbuf));
  873.     stcl_d(tempstring2, top->cn_Size);
  874.  
  875.     length = IFFXCHARS - strlen(tempstring1) - strlen(tempstring2);
  876.     for (i = 1; i <= length; i++)
  877.     {   strcat(tempstring1, " ");
  878.     }
  879.     strcat(tempstring1, tempstring2);
  880.  
  881.     /* Print the current chunk's type, with a newline. */
  882.     AddNameToTail(&List1, tempstring1);
  883.     List1Nodes = TRUE;
  884.  
  885.     if (!strcmp(IDtoStr(top->cn_ID, idbuf), "FORM"))
  886.     {   strcpy(queryform, IDtoStr(top->cn_Type, idbuf));
  887.         iffquery();
  888.     } else
  889.     {   for (i = 0; i <= CHUNKS; i++)
  890.         {   if
  891.             (   (   !strcmp(queryform, chunks[i].formname)
  892.                  || !strcmp("    ", chunks[i].formname)
  893.                  || (!strcmp("!!!!", chunks[i].formname) && (!strcmp(queryform, "ILBM") || !strcmp(queryform, "ACBM")))
  894.                  || (!strcmp("####", chunks[i].formname) && (!strcmp(queryform, "WORD") || !strcmp(queryform, "HEAD")))
  895.                 )
  896.              && !strcmp(IDtoStr(top->cn_ID, idbuf), chunks[i].chunkname)
  897.             )
  898.             {   if (!chunks[i].fixed)
  899.                 {   contents[items].bytes = top->cn_Size;
  900.                 } else
  901.                 {   contents[items].bytes = chunks[i].bytes;
  902.                 }
  903.                 if (!(contents[items].DataPtr = AllocMem(contents[items].bytes, MEMF_CLEAR)))
  904.                 {   rq("Out of memory!");
  905.                 }
  906.                 if (ReadChunkBytes(IFFHandle, contents[items].DataPtr, contents[items].bytes) < 0)
  907.                 {   rq("ReadChunkBytes() failed!");
  908.                 }
  909.     }   }   }
  910.     items++;
  911. }
  912.  
  913. MODULE void tellchunk(UWORD which)
  914. {   SLONG           svalue;
  915.     ULONG           i, uvalue, markers, currentpos;
  916.     struct DateTime DateTime;
  917.  
  918.     if (which == (UWORD) ~0)
  919.     {   return;
  920.     }
  921.  
  922.     GT_SetGadgetAttrs
  923.     (   LV61_List2,
  924.         MainWindowPtr,
  925.         NULL,
  926.         GTLV_Labels, (UWORD) ~0,
  927.         TAG_DONE
  928.     );
  929.     if (List2Nodes)
  930.     {   FreeNameNodes(&List2);
  931.         List2Nodes = FALSE;
  932.     }
  933.     NewList(&List2);
  934.  
  935.     known = FALSE;
  936.     List2Nodes = TRUE;
  937.     /* Although it is possible that this function will return with an
  938.     empty List2, remember that it is harmless to call FreeNameNodes on
  939.     a valid, empty List (ie. one which has had NewList() called). */
  940.  
  941.     if (!stricmp(contents[which].name, "FORM"))
  942.     {   chunkdesc("-");
  943.     } elif (!stricmp(contents[which].name, "(c) "))
  944.     {   chunkdesc("© Copyright");
  945.         strcpy(tempstring1, "© Copyright:        ");
  946.         strcat(tempstring1, contents[which].DataPtr);
  947.         AddNameToTail(&List2, tempstring1);
  948.     } elif (!stricmp(contents[which].name, "AUTH"))
  949.     {   chunkdesc("Author");
  950.         strcpy(tempstring1, "Author:             ");
  951.         strcat(tempstring1, contents[which].DataPtr);
  952.         AddNameToTail(&List2, tempstring1);
  953.     } elif (!stricmp(contents[which].name, "ANNO"))
  954.     {   chunkdesc("Annotation");
  955.         strcpy(tempstring1, "Annotation:         ");
  956.         strcat(tempstring1, contents[which].DataPtr);
  957.         AddNameToTail(&List2, tempstring1);
  958.     } elif (!strcmp(contents[which].name, "NAME"))
  959.     {   chunkdesc("Name");
  960.         strcpy(tempstring1, "Name:               ");
  961.         strcat(tempstring1, contents[which].DataPtr);
  962.         AddNameToTail(&List2, tempstring1);
  963.     } elif (!strcmp(queryform, "FTXT"))
  964.     {   if (!strcmp(contents[which].name, "FONS"))
  965.         {   chunkdesc("Font specifier");
  966.  
  967.             strcpy(tempstring1, "ID number:          ");
  968.             stcl_d(tempstring2, contents[which].DataPtr[0]);
  969.             strcat(tempstring1, tempstring2);
  970.             if (contents[which].DataPtr[0] > 9)
  971.             {   strcat(tempstring1, " (invalid)");
  972.             }
  973.             AddNameToTail(&List2, tempstring1);
  974.  
  975.             // Next is a pad byte ([1]).
  976.  
  977.             strcpy(tempstring1, "Proportional?       ");
  978.             uvalue = contents[which].DataPtr[2];
  979.             if (uvalue == 0)
  980.             {   strcat(tempstring1, "Unknown");
  981.             } elif (uvalue == 1)
  982.             {   strcat(tempstring1, "No");
  983.             } elif (uvalue == 2)
  984.             {   strcat(tempstring1, "Yes");
  985.             } else strcat(tempstring1, "?"); // not the same as `Unknown', of course!
  986.             AddNameToTail(&List2, tempstring1);
  987.  
  988.             strcpy(tempstring1, "Serifs?             ");
  989.             uvalue = contents[which].DataPtr[3];
  990.             if (uvalue == 0)
  991.             {   strcat(tempstring1, "Unknown");
  992.             } elif (uvalue == 1)
  993.             {   strcat(tempstring1, "No");
  994.             } elif (uvalue == 2)
  995.             {   strcat(tempstring1, "Yes");
  996.             } else strcat(tempstring1, "?"); // not the same as `Unknown', of course!
  997.             AddNameToTail(&List2, tempstring1);
  998.  
  999.             strcpy(tempstring1, "Font name:          ");
  1000.             strcat(tempstring1, &(contents[which].DataPtr[4]));
  1001.             AddNameToTail(&List2, tempstring1);
  1002.         } elif (!strcmp(contents[which].name, "CHRS"))
  1003.         {   chunkdesc("Stream of text");
  1004.     }   }
  1005.     elif (!strcmp(queryform, "SMUS"))
  1006.     {   if (!strcmp(contents[which].name, "SHDR"))
  1007.         {   chunkdesc("Global information for the score");
  1008.  
  1009.             strcpy(tempstring1, "Tempo:              ");
  1010.             uvalue = getuword(contents[which].DataPtr);
  1011.             uvalue = (uvalue << 7);
  1012.             stcl_d(tempstring2, uvalue);
  1013.             strcat(tempstring1, tempstring2);
  1014.             strcat(tempstring1, " bpm");
  1015.             AddNameToTail(&List2, tempstring1);
  1016.  
  1017.             strcpy(tempstring1, "Volume:             ");
  1018.             uvalue = contents[which].DataPtr[2];
  1019.             stcl_d(tempstring2, uvalue);
  1020.             strcat(tempstring1, tempstring2);
  1021.             strcat(tempstring1, "/127");
  1022.             AddNameToTail(&List2, tempstring1);
  1023.  
  1024.             strcpy(tempstring1, "Tracks:             ");
  1025.             uvalue = contents[which].DataPtr[3];
  1026.             stcl_d(tempstring2, uvalue);
  1027.             strcat(tempstring1, tempstring2);
  1028.             AddNameToTail(&List2, tempstring1);
  1029.         } elif (!strcmp(contents[which].name, "INS1"))
  1030.         {   chunkdesc("Identifies an instrument to use");
  1031.  
  1032.             strcpy(tempstring1, "Register number:    ");
  1033.             stcl_d(tempstring2, contents[which].DataPtr[0]); // UBYTE
  1034.             strcat(tempstring1, tempstring2);
  1035.             AddNameToTail(&List2, tempstring1);
  1036.  
  1037.             strcpy(tempstring1, "Reference type:     ");
  1038.             if (contents[which].DataPtr[1] == 0) // UBYTE
  1039.             {   strcat(tempstring1, "Find by name");
  1040.             } elif (contents[which].DataPtr[1] == 1)
  1041.             {   strcat(tempstring1, "Find on MIDI");
  1042.             } else strcat(tempstring1, "?");
  1043.             AddNameToTail(&List2, tempstring1);
  1044.  
  1045.             strcpy(tempstring1, "MIDI channel:       ");
  1046.             if (contents[which].DataPtr[1] == 1) // if find on MIDI
  1047.             {   stcl_d(tempstring2, contents[which].DataPtr[2]); // UBYTE
  1048.                 strcat(tempstring1, tempstring2);
  1049.             } else strcat(tempstring1, "n/a");
  1050.             AddNameToTail(&List2, tempstring1);
  1051.  
  1052.             strcpy(tempstring1, "MIDI preset:        ");
  1053.             if (contents[which].DataPtr[1] == 1) // if find on MIDI
  1054.             {   stcl_d(tempstring2, contents[which].DataPtr[3]); // UBYTE
  1055.                 strcat(tempstring1, tempstring2);
  1056.             } else strcat(tempstring1, "n/a");
  1057.             AddNameToTail(&List2, tempstring1);
  1058.  
  1059.             strcpy(tempstring1, "Instrument name:    ");
  1060.             strcat(tempstring1, (STRPTR) contents[which].DataPtr + 4); // STRPTR
  1061.             AddNameToTail(&List2, tempstring1);
  1062.         } elif (!strcmp(contents[which].name, "TRAK"))
  1063.         {   chunkdesc("Linear stream of events");
  1064.         } elif (!strcmp(contents[which].name, "INST"))
  1065.         {   chunkdesc("Obsolete; use INS1 instead");
  1066.         } elif (!strcmp(contents[which].name, "IRev")) // this could also perhaps be IREV
  1067.         {   chunkdesc("Instant Music private chunk");
  1068.         } elif (!strcmp(contents[which].name, "BIAS"))
  1069.         {   chunkdesc("Instant Music private chunk");
  1070.     }   }
  1071.     elif (!strcmp(queryform, "HEAD"))
  1072.     {   if (!strcmp(contents[which].name, "NEST"))
  1073.         {   chunkdesc("Nesting level");
  1074.  
  1075.             strcpy(tempstring1, "Nesting level:      ");
  1076.             uvalue = getuword(contents[which].DataPtr);
  1077.             stcl_d(tempstring2, uvalue);
  1078.             strcat(tempstring1, tempstring2);
  1079.             AddNameToTail(&List2, tempstring1);
  1080.         } elif (!strcmp(contents[which].name, "TEXT"))
  1081.         {   chunkdesc("Heading text");
  1082.     }   }
  1083.     elif (!strcmp(queryform, "WORD"))
  1084.     {   if (!strcmp(contents[which].name, "FONT"))
  1085.         {   chunkdesc("Font name/number table");
  1086.  
  1087.             strcpy(tempstring1, "Number:             ");
  1088.             uvalue = contents[which].DataPtr[0]; // UBYTE
  1089.             stcl_d(tempstring2, uvalue);
  1090.             strcat(tempstring1, tempstring2);
  1091.             AddNameToTail(&List2, tempstring1);
  1092.  
  1093.             strcpy(tempstring1, "Size:               ");
  1094.             uvalue = getuword(&contents[which].DataPtr[3]);
  1095.             stcl_d(tempstring2, uvalue);
  1096.             strcat(tempstring1, tempstring2);
  1097.             AddNameToTail(&List2, tempstring1);
  1098.  
  1099.             strcpy(tempstring1, "Instrument name:    ");
  1100.             strcat(tempstring1, (STRPTR) contents[which].DataPtr + 3); // STRPTR
  1101.             AddNameToTail(&List2, tempstring1);
  1102.         } elif (!strcmp(contents[which].name, "COLR"))
  1103.         {   chunkdesc("Colour translation table");
  1104.  
  1105.             for (i = 0; i <= 7; i++)
  1106.             {   strcpy(tempstring1, "Colour ");
  1107.                 stcl_d(tempstring2, i);
  1108.                 strcat(tempstring1, tempstring2);
  1109.                 strcat(tempstring1, ":           ");
  1110.                 uvalue = contents[which].DataPtr[i]; // UBYTE
  1111.                 stcl_d(tempstring2, uvalue);
  1112.                 strcat(tempstring1, tempstring2);
  1113.                 AddNameToTail(&List2, tempstring1);
  1114.         }   }
  1115.         elif (!strcmp(contents[which].name, "DOC "))
  1116.         {   chunkdesc("Begin document section");
  1117.  
  1118.             strcpy(tempstring1, "Starting page:      ");
  1119.             uvalue = getuword(contents[which].DataPtr);
  1120.             stcl_d(tempstring2, uvalue);
  1121.             strcat(tempstring1, tempstring2);
  1122.             AddNameToTail(&List2, tempstring1);
  1123.  
  1124.             strcpy(tempstring1, "Numbering style:    ");
  1125.             if (contents[which].DataPtr[2] == 0)
  1126.             {   strcat(tempstring1, "1, 2, 3...");
  1127.             } elif (contents[which].DataPtr[2] == 1)
  1128.             {   strcat(tempstring1, "I, II, III...");
  1129.             } elif (contents[which].DataPtr[2] == 2)
  1130.             {   strcat(tempstring1, "i, ii, iii...");
  1131.             } elif (contents[which].DataPtr[2] == 3)
  1132.             {   strcat(tempstring1, "A, B, C...");
  1133.             } elif (contents[which].DataPtr[2] == 4)
  1134.             {   strcat(tempstring1, "a, b, c...");
  1135.             } else
  1136.             {   strcat(tempstring1, "?");
  1137.             }
  1138.             AddNameToTail(&List2, tempstring1);
  1139.         } elif (!strcmp(contents[which].name, "HEAD"))
  1140.         {   chunkdesc("Begin header section");
  1141.  
  1142.             strcpy(tempstring1, "Page type:           ");
  1143.             if (contents[which].DataPtr[0] == 0)
  1144.             {   strcat(tempstring1, "None");
  1145.             } elif (contents[which].DataPtr[0] == 1)
  1146.             {   strcat(tempstring1, "Left");
  1147.             } elif (contents[which].DataPtr[0] == 2)
  1148.             {   strcat(tempstring1, "Right");
  1149.             } elif (contents[which].DataPtr[0] == 3)
  1150.             {   strcat(tempstring1, "Both");
  1151.             } else strcat(tempstring1, "?");
  1152.             AddNameToTail(&List2, tempstring1);
  1153.  
  1154.             strcpy(tempstring1, "First page?          ");
  1155.             if (contents[which].DataPtr[1] == 0)
  1156.             {   strcat(tempstring1, "No");
  1157.             } else strcat(tempstring1, "Yes");
  1158.             AddNameToTail(&List2, tempstring1);
  1159.         } elif (!strcmp(contents[which].name, "FOOT"))
  1160.         {   chunkdesc("Begin footer section");
  1161.  
  1162.             strcpy(tempstring1, "Page type:           ");
  1163.             if (contents[which].DataPtr[0] == 0)
  1164.             {   strcat(tempstring1, "None");
  1165.             } elif (contents[which].DataPtr[0] == 1)
  1166.             {   strcat(tempstring1, "Left");
  1167.             } elif (contents[which].DataPtr[0] == 2)
  1168.             {   strcat(tempstring1, "Right");
  1169.             } elif (contents[which].DataPtr[0] == 3)
  1170.             {   strcat(tempstring1, "Both");
  1171.             } else strcat(tempstring1, "?");
  1172.             AddNameToTail(&List2, tempstring1);
  1173.  
  1174.             strcpy(tempstring1, "First page?          ");
  1175.             if (contents[which].DataPtr[1] == 0)
  1176.             {   strcat(tempstring1, "No");
  1177.             } else strcat(tempstring1, "Yes");
  1178.             AddNameToTail(&List2, tempstring1);
  1179.         } elif (!strcmp(contents[which].name, "PCTS"))
  1180.         {   chunkdesc("Begin picture section");
  1181.  
  1182.             strcpy(tempstring1, "Bitplanes:           ");
  1183.             uvalue = contents[which].DataPtr[0]; // UBYTE
  1184.             stcl_d(tempstring2, uvalue);
  1185.             strcat(tempstring1, tempstring2);
  1186.             AddNameToTail(&List2, tempstring1);
  1187.         } elif (!strcmp(contents[which].name, "PARA"))
  1188.         {   chunkdesc("New paragraph format");
  1189.  
  1190.             strcpy(tempstring1, "Left indent:         ");
  1191.             uvalue = getuword(contents[which].DataPtr); // UWORD
  1192.             stcl_d(tempstring2, uvalue);
  1193.             strcat(tempstring1, tempstring2);
  1194.             strcat(tempstring1, " decipoints");
  1195.             AddNameToTail(&List2, tempstring1);
  1196.  
  1197.             strcpy(tempstring1, "Left margin:         ");
  1198.             uvalue = getuword(&(contents[which].DataPtr[2])); // UWORD
  1199.             stcl_d(tempstring2, uvalue);
  1200.             strcat(tempstring1, tempstring2);
  1201.             strcat(tempstring1, " decipoints");
  1202.             AddNameToTail(&List2, tempstring1);
  1203.  
  1204.             strcpy(tempstring1, "Right margin:        ");
  1205.             uvalue = getuword(&(contents[which].DataPtr[4])); // UWORD
  1206.             stcl_d(tempstring2, uvalue);
  1207.             strcat(tempstring1, tempstring2);
  1208.             strcat(tempstring1, " decipoints");
  1209.             AddNameToTail(&List2, tempstring1);
  1210.  
  1211.             strcpy(tempstring1, "Line spacing:        ");
  1212.             if (contents[which].DataPtr[6] == 0)
  1213.             {   strcat(tempstring1, "Single");
  1214.             } elif (contents[which].DataPtr[6] == 16)
  1215.             {   strcat(tempstring1, "Double");
  1216.             } else
  1217.             {   strcat(tempstring1, "?");
  1218.             }
  1219.             AddNameToTail(&List2, tempstring1);
  1220.  
  1221.             strcpy(tempstring1, "Justification:       ");
  1222.             if (contents[which].DataPtr[7] == 0)
  1223.             {   strcat(tempstring1, "Left");
  1224.             } elif (contents[which].DataPtr[7] == 1)
  1225.             {   strcat(tempstring1, "Centre");
  1226.             } elif (contents[which].DataPtr[7] == 2)
  1227.             {   strcat(tempstring1, "Right");
  1228.             } elif (contents[which].DataPtr[7] == 3)
  1229.             {   strcat(tempstring1, "Full");
  1230.             } else
  1231.             {   strcat(tempstring1, "?");
  1232.             }
  1233.             AddNameToTail(&List2, tempstring1);
  1234.  
  1235.             strcpy(tempstring1, "Font number:         ");
  1236.             uvalue = contents[which].DataPtr[8]; // UBYTE
  1237.             stcl_d(tempstring2, uvalue);
  1238.             strcat(tempstring1, tempstring2);
  1239.             AddNameToTail(&List2, tempstring1);
  1240.  
  1241.             strcat(tempstring1, " Style:");
  1242.             AddNameToTail(&List2, tempstring1);
  1243.  
  1244.             strcat(tempstring1, " Underlined?         ");
  1245.             if (contents[which].DataPtr[9] & 1)
  1246.             {   strcat(tempstring1, "Yes");
  1247.             } else strcat(tempstring1, "No");
  1248.             AddNameToTail(&List2, tempstring1);
  1249.  
  1250.             strcat(tempstring1, " Bold?               ");
  1251.             if (contents[which].DataPtr[9] & 2)
  1252.             {   strcat(tempstring1, "Yes");
  1253.             } else strcat(tempstring1, "No");
  1254.             AddNameToTail(&List2, tempstring1);
  1255.  
  1256.             strcat(tempstring1, " Italic?             ");
  1257.             if (contents[which].DataPtr[9] & 4)
  1258.             {   strcat(tempstring1, "Yes");
  1259.             } else strcat(tempstring1, "No");
  1260.             AddNameToTail(&List2, tempstring1);
  1261.  
  1262.             strcat(tempstring1, " Extended?           ");
  1263.             if (contents[which].DataPtr[9] & 8)
  1264.             {   strcat(tempstring1, "Yes");
  1265.             } else strcat(tempstring1, "No");
  1266.             AddNameToTail(&List2, tempstring1);
  1267.  
  1268.             strcat(tempstring1, " ColourFont?         ");
  1269.             if (contents[which].DataPtr[9] & 64)
  1270.             {   strcat(tempstring1, "Yes");
  1271.             } else strcat(tempstring1, "No");
  1272.             AddNameToTail(&List2, tempstring1);
  1273.  
  1274.             strcat(tempstring1, " Tagged?             ");
  1275.             if (contents[which].DataPtr[9] & 128)
  1276.             {   strcat(tempstring1, "Yes");
  1277.             } else strcat(tempstring1, "No");
  1278.             AddNameToTail(&List2, tempstring1);
  1279.  
  1280.             strcpy(tempstring1, "Miscellaneous style: ");
  1281.             if (contents[which].DataPtr[10] == 0)
  1282.             {   strcat(tempstring1, "None");
  1283.             } elif (contents[which].DataPtr[10] == 1)
  1284.             {   strcat(tempstring1, "Superscript");
  1285.             } elif (contents[which].DataPtr[10] == 2)
  1286.             {   strcat(tempstring1, "Subscript");
  1287.             } else
  1288.             {   strcat(tempstring1, "?");
  1289.             }
  1290.             AddNameToTail(&List2, tempstring1);
  1291.  
  1292.             strcpy(tempstring1, "Colour:              ");
  1293.             uvalue = contents[which].DataPtr[11]; // UBYTE
  1294.             stcl_d(tempstring2, uvalue);
  1295.             strcat(tempstring1, tempstring2);
  1296.             AddNameToTail(&List2, tempstring1);
  1297.         } elif (!strcmp(contents[which].name, "TABS"))
  1298.         {   chunkdesc("New tab stop types/locations");
  1299.  
  1300.             strcpy(tempstring1, "Position:            ");
  1301.             uvalue = getuword(contents[which].DataPtr); // UWORD
  1302.             stcl_d(tempstring2, uvalue);
  1303.             strcat(tempstring1, tempstring2);
  1304.             strcat(tempstring1, " decipoints");
  1305.             AddNameToTail(&List2, tempstring1);
  1306.  
  1307.             strcpy(tempstring1, "Type:                ");
  1308.             if (contents[which].DataPtr[2] == 0)
  1309.             {   strcat(tempstring1, "Left");
  1310.             } elif (contents[which].DataPtr[2] == 1)
  1311.             {   strcat(tempstring1, "Centre");
  1312.             } elif (contents[which].DataPtr[2] == 2)
  1313.             {   strcat(tempstring1, "Right");
  1314.             } elif (contents[which].DataPtr[2] == 3)
  1315.             {   strcat(tempstring1, "Decimal");
  1316.             } else
  1317.             {   strcat(tempstring1, "?");
  1318.             }
  1319.             AddNameToTail(&List2, tempstring1);
  1320.         } elif (!strcmp(contents[which].name, "PAGE"))
  1321.         {   chunkdesc("Page break");
  1322.         } elif (!strcmp(contents[which].name, "TEXT"))
  1323.         {   chunkdesc("Paragraph text");
  1324.         } elif (!strcmp(contents[which].name, "FSCC"))
  1325.         {   chunkdesc("Font/style/colour change");
  1326.  
  1327.             strcpy(tempstring1, "Location:            ");
  1328.             uvalue = getuword(contents[which].DataPtr); // UWORD
  1329.             stcl_d(tempstring2, uvalue);
  1330.             strcat(tempstring1, tempstring2);
  1331.             AddNameToTail(&List2, tempstring1);
  1332.  
  1333.             strcpy(tempstring1, "Font number:         ");
  1334.             uvalue = contents[which].DataPtr[2]; // UBYTE
  1335.             stcl_d(tempstring2, uvalue);
  1336.             strcat(tempstring1, tempstring2);
  1337.             AddNameToTail(&List2, tempstring1);
  1338.  
  1339.             strcat(tempstring1, " Style:");
  1340.             AddNameToTail(&List2, tempstring1);
  1341.  
  1342.             strcat(tempstring1, " Underlined?         ");
  1343.             if (contents[which].DataPtr[3] & 1)
  1344.             {   strcat(tempstring1, "Yes");
  1345.             } else strcat(tempstring1, "No");
  1346.             AddNameToTail(&List2, tempstring1);
  1347.  
  1348.             strcat(tempstring1, " Bold?               ");
  1349.             if (contents[which].DataPtr[3] & 2)
  1350.             {   strcat(tempstring1, "Yes");
  1351.             } else strcat(tempstring1, "No");
  1352.             AddNameToTail(&List2, tempstring1);
  1353.  
  1354.             strcat(tempstring1, " Italic?             ");
  1355.             if (contents[which].DataPtr[3] & 4)
  1356.             {   strcat(tempstring1, "Yes");
  1357.             } else strcat(tempstring1, "No");
  1358.             AddNameToTail(&List2, tempstring1);
  1359.  
  1360.             strcat(tempstring1, " Extended?           ");
  1361.             if (contents[which].DataPtr[3] & 8)
  1362.             {   strcat(tempstring1, "Yes");
  1363.             } else strcat(tempstring1, "No");
  1364.             AddNameToTail(&List2, tempstring1);
  1365.  
  1366.             strcat(tempstring1, " ColourFont?         ");
  1367.             if (contents[which].DataPtr[3] & 64)
  1368.             {   strcat(tempstring1, "Yes");
  1369.             } else strcat(tempstring1, "No");
  1370.             AddNameToTail(&List2, tempstring1);
  1371.  
  1372.             strcat(tempstring1, " Tagged?             ");
  1373.             if (contents[which].DataPtr[3] & 128)
  1374.             {   strcat(tempstring1, "Yes");
  1375.             } else strcat(tempstring1, "No");
  1376.             AddNameToTail(&List2, tempstring1);
  1377.  
  1378.             strcpy(tempstring1, "Miscellaneous style: ");
  1379.             if (contents[which].DataPtr[4] == 0)
  1380.             {   strcat(tempstring1, "None");
  1381.             } elif (contents[which].DataPtr[4] == 1)
  1382.             {   strcat(tempstring1, "Superscript");
  1383.             } elif (contents[which].DataPtr[4] == 2)
  1384.             {   strcat(tempstring1, "Subscript");
  1385.             } else
  1386.             {   strcat(tempstring1, "?");
  1387.             }
  1388.             AddNameToTail(&List2, tempstring1);
  1389.  
  1390.             strcpy(tempstring1, "Colour:              ");
  1391.             uvalue = contents[which].DataPtr[5]; // UBYTE
  1392.             stcl_d(tempstring2, uvalue);
  1393.             strcat(tempstring1, tempstring2);
  1394.             AddNameToTail(&List2, tempstring1);
  1395.         } elif (!strcmp(contents[which].name, "PINF"))
  1396.         {   chunkdesc("Picture info");
  1397.  
  1398.             strcpy(tempstring1, "Width:               ");
  1399.             uvalue = getuword(contents[which].DataPtr); // UWORD
  1400.             stcl_d(tempstring2, uvalue);
  1401.             strcat(tempstring1, tempstring2);
  1402.             AddNameToTail(&List2, tempstring1);
  1403.  
  1404.             strcpy(tempstring1, "Height:              ");
  1405.             uvalue = getuword(&(contents[which].DataPtr[2])); // UWORD
  1406.             stcl_d(tempstring2, uvalue);
  1407.             strcat(tempstring1, tempstring2);
  1408.             AddNameToTail(&List2, tempstring1);
  1409.  
  1410.             strcpy(tempstring1, "Page:                ");
  1411.             uvalue = getuword(&(contents[which].DataPtr[4])); // UWORD
  1412.             stcl_d(tempstring2, uvalue);
  1413.             strcat(tempstring1, tempstring2);
  1414.             AddNameToTail(&List2, tempstring1);
  1415.  
  1416.             strcpy(tempstring1, "X-position:          ");
  1417.             uvalue = getuword(&(contents[which].DataPtr[6])); // UWORD
  1418.             stcl_d(tempstring2, uvalue);
  1419.             strcat(tempstring1, tempstring2);
  1420.             strcat(tempstring1, " decipoints");
  1421.             AddNameToTail(&List2, tempstring1);
  1422.  
  1423.             strcpy(tempstring1, "Y-position:          ");
  1424.             uvalue = getuword(&(contents[which].DataPtr[8])); // UWORD
  1425.             stcl_d(tempstring2, uvalue);
  1426.             strcat(tempstring1, tempstring2);
  1427.             strcat(tempstring1, " decipoints");
  1428.             AddNameToTail(&List2, tempstring1);
  1429.  
  1430.             strcpy(tempstring1, "Masking:            ");
  1431.             if (contents[which].DataPtr[10] == 0)
  1432.             {   strcat(tempstring1, "0 (Opaque)");
  1433.             } elif (contents[which].DataPtr[10] == 1)
  1434.             {   strcat(tempstring1, "1 (Mask plane)");
  1435.             } elif (contents[which].DataPtr[10] == 2)
  1436.             {   strcat(tempstring1, "2 (Transparent colour)");
  1437.             } elif (contents[which].DataPtr[10] == 3)
  1438.             {   strcat(tempstring1, "3 (Lasso)");
  1439.             } else strcat(tempstring1, "?");
  1440.             AddNameToTail(&List2, tempstring1);
  1441.  
  1442.             strcpy(tempstring1, "Compression:        ");
  1443.             if (contents[which].DataPtr[11] == 0)
  1444.             {   strcat(tempstring1, "None");
  1445.             } elif (contents[which].DataPtr[11] == 1)
  1446.             {   strcat(tempstring1, "Byte run encoding");
  1447.             } else strcat(tempstring1, "?");
  1448.             AddNameToTail(&List2, tempstring1);
  1449.  
  1450.             strcpy(tempstring1, "Transparent colour: ");
  1451.             if (contents[which].DataPtr[12] != 2
  1452.              && contents[which].DataPtr[12] != 3)
  1453.             {   strcat(tempstring1, "n/a");
  1454.             } else
  1455.             {   stcl_d(tempstring2, (256 * contents[which].DataPtr[12])
  1456.                                   +        contents[which].DataPtr[13]);
  1457.                 strcat(tempstring1, tempstring2);
  1458.             }
  1459.             AddNameToTail(&List2, tempstring1);
  1460.     }   }
  1461.     elif (!strcmp(queryform, "AIFF"))
  1462.     {   if (!strcmp(contents[which].name, "MIDI"))
  1463.         {   chunkdesc("Stores MIDI data");
  1464.         } elif (!strcmp(contents[which].name, "MARK"))
  1465.         {   chunkdesc("Points to positions in the sound data");
  1466.  
  1467.             strcpy(tempstring1, "Markers:             ");
  1468.             svalue = getsword(contents[which].DataPtr);
  1469.             stcl_d(tempstring2, svalue);
  1470.             strcat(tempstring1, tempstring2);
  1471.             if (svalue < 0)
  1472.             {   strcat(tempstring1, "!");
  1473.             }
  1474.             AddNameToTail(&List2, tempstring1);
  1475.             markers = svalue;
  1476.             if (markers > 0)
  1477.             {   currentpos = 2;
  1478.                 for (i = 1; i <= markers; i++)
  1479.                 {   strcpy(tempstring1, "Marker ");
  1480.                     stcl_d(tempstring2, i);
  1481.                     strcat(tempstring1, tempstring2);
  1482.                     strcat(tempstring1, ":");
  1483.                     AddNameToTail(&List2, tempstring1);
  1484.  
  1485.                     strcpy(tempstring1, " ID:                 ");
  1486.                     svalue = getsword(&(contents[which].name[currentpos]));
  1487.                     stcl_d(tempstring2, svalue);
  1488.                     strcat(tempstring1, tempstring2);
  1489.                     if (svalue < 1)
  1490.                     {   strcat(tempstring1, "!");
  1491.                     }
  1492.                     AddNameToTail(&List2, tempstring1);
  1493.                     currentpos += 2;
  1494.  
  1495.                     strcpy(tempstring1, " Position:           ");
  1496.                     uvalue = getulong(&(contents[which].name[currentpos]));
  1497.                     stcl_d(tempstring2, uvalue);
  1498.                     strcat(tempstring1, tempstring2);
  1499.                     AddNameToTail(&List2, tempstring1);
  1500.                     currentpos += 4;
  1501.  
  1502.                     strcpy(tempstring1, " Name:               ");
  1503.                     uvalue = contents[which].name[currentpos++];
  1504.                     // the number of characters in the string
  1505.                     if (uvalue < MEDFIELD)
  1506.                     {   strncat(tempstring1, &(contents[which].name[currentpos]), uvalue);
  1507.                     } else
  1508.                     {   strncat(tempstring1, &(contents[which].name[currentpos]), MEDFIELD);
  1509.                     }
  1510.                     AddNameToTail(&List2, tempstring1);
  1511.                     currentpos += uvalue;
  1512.                     if (uvalue % 2)
  1513.                     {   currentpos++; // skip pad byte, if appropriate
  1514.         }   }   }   }
  1515.         elif (!strcmp(contents[which].name, "AESD"))
  1516.         {   chunkdesc("Pertinent to autio recording devices");
  1517.         } elif (!strcmp(contents[which].name, "COMT"))
  1518.         {   chunkdesc("Stores comments");
  1519.  
  1520.             strcpy(tempstring1, "Comments:            ");
  1521.             svalue = getsword(contents[which].DataPtr);
  1522.             stcl_d(tempstring2, svalue);
  1523.             strcat(tempstring1, tempstring2);
  1524.             if (svalue < 0)
  1525.             {   strcat(tempstring1, "!");
  1526.             }
  1527.             AddNameToTail(&List2, tempstring1);
  1528.  
  1529.             // we could have a 'comments' variable, but we just reuse
  1530.             // the 'markers' variable.
  1531.             markers = svalue;
  1532.             if (markers > 0)
  1533.             {   currentpos = 2;
  1534.                 for (i = 1; i <= markers; i++)
  1535.                 {   strcpy(tempstring1, "Comment ");
  1536.                     stcl_d(tempstring2, i);
  1537.                     strcat(tempstring1, tempstring2);
  1538.                     strcat(tempstring1, ":");
  1539.                     AddNameToTail(&List2, tempstring1);
  1540.  
  1541.                     strcpy(tempstring1, " Created on:         ");
  1542.                     uvalue = getulong(&(contents[which].DataPtr[currentpos]));
  1543.                     DateTime.dat_Stamp.ds_Days   =   uvalue / 86400;             // days since 1/1/78
  1544.                     DateTime.dat_Stamp.ds_Minute =  (uvalue % 86400) / 60;       // minutes in day
  1545.                     DateTime.dat_Stamp.ds_Tick   = ((uvalue % 86400) % 60) * 50; // ticks in minute
  1546.                     DateTime.dat_Format          = FORMAT_DOS;
  1547.                     DateTime.dat_Flags           = DTF_SUBST;
  1548.                     DateTime.dat_StrDay          = weekdaystring;
  1549.                     DateTime.dat_StrDate         = datestring;
  1550.                     DateTime.dat_StrTime         = timestring;
  1551.                     if (!DateToStr(&DateTime))
  1552.                     {   rq("DateToStr() failed!");
  1553.                     }
  1554.                     strcat(tempstring1, timestring);
  1555.                     strcat(tempstring1, " ");
  1556.                     strcat(tempstring1, weekdaystring);
  1557.                     strcat(tempstring1, " ");
  1558.                     strcat(tempstring1, datestring);
  1559.                     AddNameToTail(&List2, tempstring1);
  1560.                     currentpos += 4;
  1561.  
  1562.                     strcpy(tempstring1, " Marker ID:          ");
  1563.                     svalue = getsword(&(contents[which].DataPtr[currentpos]));
  1564.                     stcl_d(tempstring2, svalue);
  1565.                     strcat(tempstring1, tempstring2);
  1566.                     if (svalue < 1)
  1567.                     {    strcat(tempstring1, "!");
  1568.                     }
  1569.                     AddNameToTail(&List2, tempstring1);
  1570.                     currentpos += 2;
  1571.  
  1572.                     strcpy(tempstring1, " Comment:            ");
  1573.                     uvalue = getuword(&(contents[which].DataPtr[currentpos]));
  1574.                     // the number of characters in the string
  1575.                     currentpos += 2;
  1576.                     if (uvalue < MEDFIELD)
  1577.                     {   strncat(tempstring1, &(contents[which].name[currentpos]), uvalue);
  1578.                     } else
  1579.                     {   strncat(tempstring1, &(contents[which].name[currentpos]), MEDFIELD);
  1580.                     }
  1581.                     AddNameToTail(&List2, tempstring1);
  1582.                     currentpos += uvalue;
  1583.                     if (uvalue % 2)
  1584.                     {   currentpos++; // skip pad byte, if appropriate
  1585.         }   }   }   }
  1586.         elif (!strcmp(contents[which].name, "COMM"))
  1587.         {   chunkdesc("Fundamental parameters for the sampled sound");
  1588.  
  1589.             strcpy(tempstring1, "Channels:            ");
  1590.             svalue = getsword(contents[which].DataPtr);
  1591.             stcl_d(tempstring2, svalue);
  1592.             strcat(tempstring1, tempstring2);
  1593.             if (svalue == 1)
  1594.             {   strcat(tempstring1, " (mono)");
  1595.             } elif (svalue == 2)
  1596.             {   strcat(tempstring1, " (stereo)");
  1597.             } elif (svalue > 2)
  1598.             {   strcat(tempstring1, " (surround)");
  1599.             }
  1600.             AddNameToTail(&List2, tempstring1);
  1601.  
  1602.             strcpy(tempstring1, "Sample frames:       ");
  1603.             uvalue = getulong(&(contents[which].DataPtr[2]));
  1604.             stcl_d(tempstring2, uvalue);
  1605.             strcat(tempstring1, tempstring2);
  1606.             AddNameToTail(&List2, tempstring1);
  1607.  
  1608.             strcpy(tempstring1, "Sample quality:      ");
  1609.             svalue = getsword(&(contents[which].DataPtr[6]));
  1610.             stcl_d(tempstring2, svalue);
  1611.             strcat(tempstring1, tempstring2);
  1612.             strcat(tempstring1, "-bit");
  1613.             AddNameToTail(&List2, tempstring1);
  1614.  
  1615.             /* This is an 80-bit IEEE 754 Apple-style (SANE) floating
  1616.             point number (not yet implemented):
  1617.                  79 Sign
  1618.               64:78 Exponent
  1619.                0:63 Mantissa */
  1620.             strcpy(tempstring1, "Playback rate:       -");
  1621.             AddNameToTail(&List2, tempstring1);
  1622.         } elif (!strcmp(contents[which].name, "APPL"))
  1623.         {   chunkdesc("Application-specific data");
  1624.  
  1625.             strcpy(tempstring1, "Application:         ");
  1626.             strcat(tempstring1, contents[which].DataPtr);
  1627.             if (!strcmp(tempstring1, "pdos"))
  1628.             {   strcat(tempstring1, " (Apple II)");
  1629.             }
  1630.             AddNameToTail(&List2, tempstring1);
  1631.         } elif (!strcmp(contents[which].name, "SSND"))
  1632.         {   chunkdesc("The actual sample frames");
  1633.  
  1634.             strcpy(tempstring1, "Offset:              ");
  1635.             uvalue = getulong(contents[which].DataPtr);
  1636.             stcl_d(tempstring2, uvalue);
  1637.             strcat(tempstring1, tempstring2);
  1638.             AddNameToTail(&List2, tempstring1);
  1639.  
  1640.             strcpy(tempstring1, "Block size:          ");
  1641.             uvalue = getulong(&(contents[which].DataPtr[4]));
  1642.             stcl_d(tempstring2, uvalue);
  1643.             strcat(tempstring1, tempstring2);
  1644.             AddNameToTail(&List2, tempstring1);
  1645.         } elif (!strcmp(contents[which].name, "INST"))
  1646.         {   chunkdesc("The actual sample frames");
  1647.  
  1648.             strcpy(tempstring1, "Base note:           ");
  1649.             svalue = getsbyte(&(contents[which].DataPtr[0]));
  1650.             stcl_d(tempstring2, svalue);
  1651.             strcat(tempstring1, tempstring2);
  1652.             if (svalue < 0 || svalue > 127)
  1653.                 strcat(tempstring1, "!");
  1654.             AddNameToTail(&List2, tempstring1);
  1655.  
  1656.             strcpy(tempstring1, "Detune:              ");
  1657.             svalue = getsbyte(&(contents[which].DataPtr[1]));
  1658.             stcl_d(tempstring2, svalue);
  1659.             strcat(tempstring1, tempstring2);
  1660.             if (svalue < -50 || svalue > 50)
  1661.                 strcat(tempstring1, "!");
  1662.             AddNameToTail(&List2, tempstring1);
  1663.  
  1664.             strcpy(tempstring1, "Low note:            ");
  1665.             svalue = getsbyte(&(contents[which].DataPtr[2]));
  1666.             stcl_d(tempstring2, svalue);
  1667.             strcat(tempstring1, tempstring2);
  1668.             if (svalue < 0 || svalue > 127)
  1669.                 strcat(tempstring1, "!");
  1670.             AddNameToTail(&List2, tempstring1);
  1671.  
  1672.             strcpy(tempstring1, "High note:           ");
  1673.             svalue = getsbyte(&(contents[which].DataPtr[3]));
  1674.             stcl_d(tempstring2, svalue);
  1675.             strcat(tempstring1, tempstring2);
  1676.             if (svalue < 0 || svalue > 127)
  1677.                 strcat(tempstring1, "!");
  1678.             AddNameToTail(&List2, tempstring1);
  1679.  
  1680.             strcpy(tempstring1, "Low velocity:        ");
  1681.             svalue = getsbyte(&(contents[which].DataPtr[4]));
  1682.             stcl_d(tempstring2, svalue);
  1683.             strcat(tempstring1, tempstring2);
  1684.             if (svalue < 1 || svalue > 127)
  1685.                 strcat(tempstring1, "!");
  1686.             AddNameToTail(&List2, tempstring1);
  1687.  
  1688.             strcpy(tempstring1, "High velocity:       ");
  1689.             svalue = getsbyte(&(contents[which].DataPtr[5]));
  1690.             stcl_d(tempstring2, svalue);
  1691.             strcat(tempstring1, tempstring2);
  1692.             if (svalue < 1 || svalue > 127)
  1693.                 strcat(tempstring1, "!");
  1694.             AddNameToTail(&List2, tempstring1);
  1695.  
  1696.             strcpy(tempstring1, "Gain:                ");
  1697.             svalue = getsword(&(contents[which].DataPtr[6]));
  1698.             stcl_d(tempstring2, svalue);
  1699.             strcat(tempstring1, tempstring2);
  1700.             AddNameToTail(&List2, tempstring1);
  1701.  
  1702.             strcpy(tempstring1, "Sustain loop:");
  1703.             svalue = getsword(&(contents[which].DataPtr[8]));
  1704.             if (svalue == 0)
  1705.             {   strcpy(tempstring1, " No looping");
  1706.             } elif (svalue == 1)
  1707.             {   strcpy(tempstring1, " Forwards looping");
  1708.             } elif (svalue == 2)
  1709.             {   strcpy(tempstring1, " Forwards/backwards looping");
  1710.             } else
  1711.             {   strcpy(tempstring1, " ?");
  1712.             }
  1713.             AddNameToTail(&List2, tempstring1);
  1714.             strcpy(tempstring1, " Begin loop:         ");
  1715.             svalue = getsword(&(contents[which].DataPtr[10]));
  1716.             stcl_d(tempstring1, svalue);
  1717.             AddNameToTail(&List2, tempstring1);
  1718.             strcpy(tempstring1, " End loop:           ");
  1719.             svalue = getsword(&(contents[which].DataPtr[12]));
  1720.             stcl_d(tempstring1, svalue);
  1721.             AddNameToTail(&List2, tempstring1);
  1722.  
  1723.             strcpy(tempstring1, "Release loop:        ");
  1724.  
  1725.             svalue = getsword(&(contents[which].DataPtr[14]));
  1726.             if (svalue == 0)
  1727.             {   strcpy(tempstring1, " No looping");
  1728.             } elif (svalue == 1)
  1729.             {   strcpy(tempstring1, " Forwards looping");
  1730.             } elif (svalue == 2)
  1731.             {   strcpy(tempstring1, " Forwards/backwards looping");
  1732.             } else
  1733.             {   strcpy(tempstring1, " ?");
  1734.             }
  1735.             AddNameToTail(&List2, tempstring1);
  1736.             strcpy(tempstring1, " Begin loop:         ");
  1737.             svalue = getsword(&(contents[which].DataPtr[16]));
  1738.             stcl_d(tempstring1, svalue);
  1739.             AddNameToTail(&List2, tempstring1);
  1740.             strcpy(tempstring1, " End loop:           ");
  1741.             svalue = getsword(&(contents[which].DataPtr[18]));
  1742.             stcl_d(tempstring1, svalue);
  1743.             AddNameToTail(&List2, tempstring1);
  1744.     }   }
  1745.     elif (!strcmp(queryform, "8SVX"))
  1746.     {   if (!strcmp(contents[which].name, "ATAK"))
  1747.         {   chunkdesc("Gives attack amplitude contour (envelope)");
  1748.         } elif (!strcmp(contents[which].name, "RLSE"))
  1749.         {   chunkdesc("Gives release amplitude contour (envelope)");
  1750.         } elif (!strcmp(contents[which].name, "BODY"))
  1751.         {   chunkdesc("Sound data chunk");
  1752.         } elif (!strcmp(contents[which].name, "FADE"))
  1753.         {   chunkdesc("Fade away to silence");
  1754.  
  1755.             strcpy(tempstring1, "Fade start:          ");
  1756.             uvalue = getulong(contents[which].DataPtr);
  1757.             stcl_d(tempstring2, uvalue);
  1758.             strcat(tempstring1, tempstring2);
  1759.             AddNameToTail(&List2, tempstring1);
  1760.         } elif (!strcmp(contents[which].name, "SEQN"))
  1761.         {   chunkdesc("Multiple loop sequencing");
  1762.  
  1763.             currentpos = 0;
  1764.             while (currentpos < contents[which].bytes)
  1765.             {   strcpy(tempstring1, "Loop start:          ");
  1766.                 uvalue = getulong(&(contents[which].DataPtr[currentpos]));
  1767.                 stcl_d(tempstring2, uvalue);
  1768.                 strcat(tempstring1, tempstring2);
  1769.                 if (uvalue % 4)
  1770.                 {   strcat(tempstring1, "!");
  1771.                 }
  1772.                 AddNameToTail(&List2, tempstring1);
  1773.                 currentpos += 4;
  1774.  
  1775.                 strcpy(tempstring1, "Loop end:            ");
  1776.                 uvalue = getulong(&(contents[which].DataPtr[currentpos]));
  1777.                 stcl_d(tempstring2, uvalue);
  1778.                 strcat(tempstring1, tempstring2);
  1779.                 if (uvalue % 4)
  1780.                 {   strcat(tempstring1, "!");
  1781.                 }
  1782.                 AddNameToTail(&List2, tempstring1);
  1783.                 currentpos += 4;
  1784.         }   }
  1785.         elif (!strcmp(contents[which].name, "CHAN"))
  1786.         {   chunkdesc("Specified channel, or combination of channels");
  1787.             strcpy(tempstring1, "Channel:             ");
  1788.             svalue = getslong(contents[which].DataPtr);
  1789.             if (svalue == 2)
  1790.             {   strcat(tempstring1, "Left");
  1791.             } elif (svalue == 4)
  1792.             {   strcat(tempstring1, "Right");
  1793.             } elif (svalue == 6)
  1794.             {   strcat(tempstring1, "Stereo (both)");
  1795.             } else strcat(tempstring1, "?");
  1796.             AddNameToTail(&List2, tempstring1);
  1797.         } elif (!strcmp(contents[which].name, "PAN "))
  1798.         {   chunkdesc("Stereo sound using a single array of data");
  1799.             strcpy(tempstring1, "Sound position:      ");
  1800.             svalue = getslong(contents[which].DataPtr);
  1801.             stcl_d(tempstring2, svalue);
  1802.             strcat(tempstring1, tempstring2);
  1803.             strcat(tempstring1, "/65536 ");
  1804.             if (svalue < 32768)
  1805.             {    strcat(tempstring1, "(left)");
  1806.             } elif (svalue > 32678)
  1807.             {    strcat(tempstring1, "(right)");
  1808.             } else
  1809.             {    // assert(svalue == 32678);
  1810.                  strcat(tempstring1, "(centre)");
  1811.             }
  1812.             AddNameToTail(&List2, tempstring1);
  1813.         } elif (!strcmp(contents[which].name, "VHDR"))
  1814.         {   chunkdesc("Playback parameters for the sampled waveforms");
  1815.             strcpy(tempstring1, "1-shot samples:      ");
  1816.             uvalue = getulong(contents[which].DataPtr);
  1817.             stcl_d(tempstring2, uvalue);
  1818.             strcat(tempstring1, tempstring2);
  1819.             AddNameToTail(&List2, tempstring1);
  1820.  
  1821.             strcpy(tempstring1, "Repeat samples:      ");
  1822.             uvalue = getulong(&(contents[which].DataPtr[4]));
  1823.             stcl_d(tempstring2, uvalue);
  1824.             strcat(tempstring1, tempstring2);
  1825.             AddNameToTail(&List2, tempstring1);
  1826.  
  1827.             strcpy(tempstring1, "Samples per cycle:   ");
  1828.             uvalue = getulong(&(contents[which].DataPtr[8]));
  1829.             stcl_d(tempstring2, uvalue);
  1830.             strcat(tempstring1, tempstring2);
  1831.             AddNameToTail(&List2, tempstring1);
  1832.  
  1833.             strcpy(tempstring1, "Sampling rate:       ");
  1834.             uvalue = getuword(&(contents[which].DataPtr[12]));
  1835.             stcl_d(tempstring2, uvalue);
  1836.             strcat(tempstring1, tempstring2);
  1837.             AddNameToTail(&List2, tempstring1);
  1838.  
  1839.             strcpy(tempstring1, "Octaves:             ");
  1840.             uvalue = contents[which].DataPtr[14]; // UBYTE
  1841.             stcl_d(tempstring2, uvalue);
  1842.             strcat(tempstring1, tempstring2);
  1843.             AddNameToTail(&List2, tempstring1);
  1844.  
  1845.             strcpy(tempstring1, "Compression:         "); // UBYTE
  1846.             if (contents[which].DataPtr[15] == 0)
  1847.             {   strcat(tempstring1, "None");
  1848.             } elif (contents[which].DataPtr[15] == 1)
  1849.             {   strcat(tempstring1, "Fibonacci-delta encoding");
  1850.             } else strcat(tempstring1, "?");
  1851.             AddNameToTail(&List2, tempstring1);
  1852.  
  1853.             strcpy(tempstring1, "Volume:              ");
  1854.             svalue = getslong(&(contents[which].DataPtr[16]));
  1855.             svalue /= 1024; // LONG (Fixed)
  1856.             stcl_d(tempstring2, svalue);
  1857.             strcat(tempstring1, tempstring2);
  1858.             strcat(tempstring1, "/64");
  1859.             AddNameToTail(&List2, tempstring1);
  1860.     }   }
  1861.     elif (!strcmp(queryform, "ILBM"))
  1862.     {   if (!strcmp(contents[which].name, "CAMG"))
  1863.         {   chunkdesc("Specifies the Amiga display mode of a picture");
  1864.  
  1865.             strcpy(tempstring1, "ModeID:             $");
  1866.             uvalue = getulong(contents[which].DataPtr);
  1867.             stcl_h(tempstring2, uvalue);
  1868.             strcat(tempstring1, tempstring2);
  1869.             AddNameToTail(&List2, tempstring1);
  1870.         } elif (!strcmp(contents[which].name, "DPI "))
  1871.         {   chunkdesc("Dots per inch");
  1872.  
  1873.             strcpy(tempstring1, "Dots per inch:      ");
  1874.             // There are 20 characters in the first column.
  1875.             uvalue = getuword(contents[which].DataPtr);
  1876.             stcl_h(tempstring2, uvalue);
  1877.             strcat(tempstring1, tempstring2);
  1878.             strcat(tempstring1, "x");
  1879.             uvalue = getuword(&(contents[which].DataPtr[2]));
  1880.             stcl_h(tempstring2, uvalue);
  1881.             strcat(tempstring1, tempstring2);
  1882.             AddNameToTail(&List2, tempstring1);
  1883.         } elif (!strcmp(contents[which].name, "CMAP"))
  1884.         {   chunkdesc("Colour map data");
  1885.         } elif (!strcmp(contents[which].name, "BODY"))
  1886.         {   chunkdesc("Image data chunk");
  1887.         } elif (!strcmp(contents[which].name, "EPSF"))
  1888.         {   chunkdesc("Encapsulated PostScript representation of image");
  1889.  
  1890.             strcpy(tempstring1, "Left X:             ");
  1891.             svalue = getsword(contents[which].DataPtr);
  1892.             stcl_d(tempstring2, svalue);
  1893.             strcat(tempstring1, tempstring2);
  1894.             AddNameToTail(&List2, tempstring1);
  1895.  
  1896.             strcpy(tempstring1, "Top Y:              ");
  1897.             svalue = getsword(&(contents[which].DataPtr[2]));
  1898.             stcl_d(tempstring2, svalue);
  1899.             strcat(tempstring1, tempstring2);
  1900.             AddNameToTail(&List2, tempstring1);
  1901.  
  1902.             strcpy(tempstring1, "Right X:            ");
  1903.             svalue = getsword(&(contents[which].DataPtr[4]));
  1904.             stcl_d(tempstring2, svalue);
  1905.             strcat(tempstring1, tempstring2);
  1906.             AddNameToTail(&List2, tempstring1);
  1907.  
  1908.             strcpy(tempstring1, "Bottom Y:           ");
  1909.             svalue = getsword(&(contents[which].DataPtr[6]));
  1910.             stcl_d(tempstring2, svalue);
  1911.             strcat(tempstring1, tempstring2);
  1912.             AddNameToTail(&List2, tempstring1);
  1913.         } elif (!strcmp(contents[which].name, "DEST"))
  1914.         {   chunkdesc("Scatter bitplanes into a deeper destination image");
  1915.  
  1916.             strcpy(tempstring1, "Source bitplanes:   ");
  1917.             stcl_d(tempstring2, contents[which].DataPtr[0]);
  1918.             strcat(tempstring1, tempstring2);
  1919.             AddNameToTail(&List2, tempstring1);
  1920.  
  1921.             // next (1) is a pad byte.
  1922.  
  1923.             strcpy(tempstring1, "PlanePick:          %"); // UWORD
  1924.             binarize(contents[which].DataPtr[2]);
  1925.             binarize(contents[which].DataPtr[3]);
  1926.             AddNameToTail(&List2, tempstring1);
  1927.  
  1928.             strcpy(tempstring1, "PlaneOnOff:         %"); // UWORD
  1929.             binarize(contents[which].DataPtr[4]);
  1930.             binarize(contents[which].DataPtr[5]);
  1931.             AddNameToTail(&List2, tempstring1);
  1932.  
  1933.             strcpy(tempstring1, "PlaneMask:          %"); // UWORD
  1934.             binarize(contents[which].DataPtr[6]);
  1935.             binarize(contents[which].DataPtr[7]);
  1936.             AddNameToTail(&List2, tempstring1);
  1937.         } elif (!strcmp(contents[which].name, "GRAB"))
  1938.         {   chunkdesc("Locates a hotspot, when used as a pointer or brush");
  1939.  
  1940.             strcpy(tempstring1, "Hotspot:            ");
  1941.             svalue = getsword(contents[which].DataPtr);
  1942.             stcl_h(tempstring2, svalue);
  1943.             strcat(tempstring1, tempstring2);
  1944.             strcat(tempstring1, ",");
  1945.             svalue = getsword(&(contents[which].DataPtr[2]));
  1946.             stcl_h(tempstring2, svalue);
  1947.             strcat(tempstring1, tempstring2);
  1948.             AddNameToTail(&List2, tempstring1);
  1949.         } elif (!strcmp(contents[which].name, "SPRT"))
  1950.         {   chunkdesc("This image is intended as a sprite");
  1951.  
  1952.             strcpy(tempstring1, "Precedence:         ");
  1953.             uvalue = getuword(contents[which].DataPtr);
  1954.  
  1955.             stcl_h(tempstring2, uvalue);
  1956.             strcat(tempstring1, tempstring2);
  1957.             AddNameToTail(&List2, tempstring1);
  1958.         } elif (!strcmp(contents[which].name, "BMHD"))
  1959.         {   /* UWORD w, h;               0-1, 2-3
  1960.             WORD  x, y;                  4-5, 6-7
  1961.             UBYTE nPlanes;               8
  1962.             UBYTE Masking;               9
  1963.             UBYTE Compression;           10
  1964.             UBYTE pad;                   11
  1965.             UWORD transparentColour;     12-13
  1966.             UBYTE xAspect, yAspect;      14, 15
  1967.             WORD  pageWidth, pageHeight; 16-17, 18-19 */
  1968.  
  1969.             chunkdesc("Data necessary to understand the BODY chunk");
  1970.             strcpy(tempstring1, "Image size:         ");
  1971.             stcl_d(tempstring2, (256 * contents[which].DataPtr[0])
  1972.                               +        contents[which].DataPtr[1]); // UWORD
  1973.             strcat(tempstring1, tempstring2);
  1974.             strcat(tempstring1, "x");
  1975.             stcl_d(tempstring2, (256 * contents[which].DataPtr[2])
  1976.                               +        contents[which].DataPtr[3]); // UWORD
  1977.             strcat(tempstring1, tempstring2);
  1978.             AddNameToTail(&List2, tempstring1);
  1979.  
  1980.             strcpy(tempstring1, "Position:           ");
  1981.             stcl_d(tempstring2, (256 * contents[which].DataPtr[4])
  1982.                               +        contents[which].DataPtr[5]); // WORD
  1983.             strcat(tempstring1, tempstring2);
  1984.             strcat(tempstring1, ",");
  1985.             stcl_d(tempstring2, (256 * contents[which].DataPtr[6])
  1986.                               +        contents[which].DataPtr[7]); // WORD
  1987.             strcat(tempstring1, tempstring2);
  1988.             AddNameToTail(&List2, tempstring1);
  1989.  
  1990.             strcpy(tempstring1, "Bitplanes:          ");
  1991.             stcl_d(tempstring2, (LONG) contents[which].DataPtr[8]);
  1992.             strcat(tempstring1, tempstring2);
  1993.             AddNameToTail(&List2, tempstring1);
  1994.             // tell number of colours to user?
  1995.  
  1996.             strcpy(tempstring1, "Masking:            ");
  1997.             if (contents[which].DataPtr[9] == 0)
  1998.             {   strcat(tempstring1, "0 (Opaque)");
  1999.             } elif (contents[which].DataPtr[9] == 1)
  2000.             {   strcat(tempstring1, "1 (Mask plane)");
  2001.             } elif (contents[which].DataPtr[9] == 2)
  2002.             {   strcat(tempstring1, "2 (Transparent colour)");
  2003.             } elif (contents[which].DataPtr[9] == 3)
  2004.             {   strcat(tempstring1, "3 (Lasso)");
  2005.             } else strcat(tempstring1, "?");
  2006.             AddNameToTail(&List2, tempstring1);
  2007.  
  2008.             strcpy(tempstring1, "Compression:        ");
  2009.             if (contents[which].DataPtr[10] == 0)
  2010.             {   strcat(tempstring1, "None");
  2011.             } elif (contents[which].DataPtr[10] == 1)
  2012.             {   strcat(tempstring1, "Byte run encoding");
  2013.             } else strcat(tempstring1, "?");
  2014.             AddNameToTail(&List2, tempstring1);
  2015.  
  2016.             // Next (11) is a pad byte.
  2017.  
  2018.             strcpy(tempstring1, "Transparent colour: ");
  2019.             if (contents[which].DataPtr[9] != 2
  2020.              && contents[which].DataPtr[9] != 3)
  2021.             {   strcat(tempstring1, "n/a");
  2022.             } else
  2023.             {   stcl_d(tempstring2, (256 * contents[which].DataPtr[12])
  2024.                                   +        contents[which].DataPtr[13]);
  2025.                 strcat(tempstring1, tempstring2);
  2026.             }
  2027.             AddNameToTail(&List2, tempstring1);
  2028.  
  2029.             strcpy(tempstring1, "Aspect ratio:       ");
  2030.             stcl_d(tempstring2, (UBYTE) contents[which].DataPtr[14]);
  2031.             strcat(tempstring1, tempstring2);
  2032.             strcat(tempstring1, ":");
  2033.             stcl_d(tempstring2, (UBYTE) contents[which].DataPtr[15]);
  2034.             strcat(tempstring1, tempstring2);
  2035.             AddNameToTail(&List2, tempstring1);
  2036.  
  2037.             strcpy(tempstring1, "Page size:          ");
  2038.             stcl_d(tempstring2, (256 * contents[which].DataPtr[16])
  2039.                               +        contents[which].DataPtr[17]); // WORD
  2040.             strcat(tempstring1, tempstring2);
  2041.             strcat(tempstring1, "x");
  2042.             stcl_d(tempstring2, (256 * contents[which].DataPtr[18])
  2043.                               +        contents[which].DataPtr[19]); // WORD
  2044.             strcat(tempstring1, tempstring2);
  2045.             AddNameToTail(&List2, tempstring1);
  2046.     }   }
  2047.     GT_SetGadgetAttrs
  2048.     (   LV61_List2,
  2049.         MainWindowPtr,
  2050.         NULL,
  2051.         GTLV_Labels, &List2,
  2052.         TAG_DONE
  2053.     );
  2054.     if (!known)
  2055.     {   chunkdesc("?");
  2056. }   }
  2057.  
  2058. MODULE void chunkdesc(STRPTR desc)
  2059. {   GT_SetGadgetAttrs
  2060.     (   TE61_ChunkDesc,
  2061.         MainWindowPtr,
  2062.         NULL,
  2063.         GTTX_Text, desc,
  2064.         TAG_DONE
  2065.     );
  2066.     known = TRUE;
  2067. }
  2068.  
  2069. MODULE void binarize(UBYTE data)
  2070. {   ULONG i;
  2071.  
  2072.     for (i = 7; i >= 0; i--)
  2073.     {   if (data & (1 << i))
  2074.         {   strcat(tempstring1, "1");
  2075.         } else strcat(tempstring1, "0");
  2076. }   }
  2077.  
  2078. MODULE ULONG getulong(UBYTE* start)
  2079. {   return (ULONG) ((16777216 * *(start    ))
  2080.                   + (   65536 * *(start + 1))
  2081.                   + (     256 * *(start + 2))
  2082.                   +             *(start + 3));
  2083. }
  2084. MODULE SLONG getslong(UBYTE* start)
  2085. {   return (SLONG) ((16777216 * *(start    ))
  2086.                   + (   65536 * *(start + 1))
  2087.                   + (     256 * *(start + 2))
  2088.                   +             *(start + 3));
  2089. }
  2090. MODULE ULONG getuword(UBYTE* start)
  2091. {   return (ULONG) ((     256 * *(start    ))
  2092.                   +             *(start + 1));
  2093. }
  2094. MODULE SLONG getsword(UBYTE* start)
  2095. {   return (SLONG) ((     256 * *(start    ))
  2096.                   +             *(start + 1));
  2097. }
  2098. MODULE SLONG getsbyte(UBYTE* start)
  2099. {   return (SBYTE) (*start);
  2100. }
  2101.  
  2102. MODULE void writeiffgadgets(void)
  2103. {   // update the gadgets according to variables
  2104.  
  2105.     GT_SetGadgetAttrs
  2106.     (   CB61_CD,
  2107.         MainWindowPtr,
  2108.         NULL,
  2109.         GTCB_Checked, iff.cd,
  2110.         TAG_DONE
  2111.     );
  2112.     GT_SetGadgetAttrs
  2113.     (   CB61_RKM,
  2114.         MainWindowPtr,
  2115.         NULL,
  2116.         GTCB_Checked, iff.rkm,
  2117.         TAG_DONE
  2118.     );
  2119.     GT_SetGadgetAttrs
  2120.     (   CB61_Obsolete,
  2121.         MainWindowPtr,
  2122.         NULL,
  2123.         GTCB_Checked, iff.obsolete,
  2124.         TAG_DONE
  2125.     );
  2126.     GT_SetGadgetAttrs
  2127.     (   CB61_Private,
  2128.         MainWindowPtr,
  2129.         NULL,
  2130.         GTCB_Checked, iff.private,
  2131.         TAG_DONE
  2132.     );
  2133.     GT_SetGadgetAttrs
  2134.     (   CB61_Proposal,
  2135.         MainWindowPtr,
  2136.         NULL,
  2137.         GTCB_Checked, iff.proposal,
  2138.         TAG_DONE
  2139.     );
  2140.     GT_SetGadgetAttrs
  2141.     (   CB61_Reserved,
  2142.         MainWindowPtr,
  2143.         NULL,
  2144.         GTCB_Checked, iff.reserved,
  2145.         TAG_DONE
  2146.     );
  2147.     GT_SetGadgetAttrs
  2148.     (   CB61_Standard,
  2149.         MainWindowPtr,
  2150.         NULL,
  2151.         GTCB_Checked, iff.standard,
  2152.         TAG_DONE
  2153.     );
  2154.     GT_SetGadgetAttrs
  2155.     (   CB61_Unregistered,
  2156.         MainWindowPtr,
  2157.         NULL,
  2158.         GTCB_Checked, iff.unregistered,
  2159.         TAG_DONE
  2160.     );
  2161.     GT_SetGadgetAttrs
  2162.     (   ST61_FORMID,
  2163.         MainWindowPtr,
  2164.         NULL,
  2165.         GTST_String, queryform,
  2166.         TAG_DONE
  2167.     );
  2168.     chunkdesc("-");
  2169. }
  2170.